Exception handling within if statements in Java

You should think of try/catch as any other statement. So you can put it inside any of two branches of if/then/else statement, but it have to be whole inside:

if(statement){
    ...    
    try{
        ...
    }catch(...){
    ...
    }
    ...
}else{
    ...    
    try{
        ...
    }catch(...){
    ...
    }
    ...
}

If you have to catch multiple exceptions you can achieve this by multiple catch parts:

    try{
        ...
    }catch(Exception1 e1){
    ...
    }catch(Exception2 e2){
    ...
    }catch(Exception3 e3){
    ...
    }

What you want here is to create your own Exception class.

To create an exception class say you need to extend Exception class. Here's an example. Lets say my custom exception class should be named as MyFileErrorException

So I create a new class like this -

class MyFileErrorException extends Exception {

    private String message = null;

    public MyFileErrorException() {
        super();
    }

    public MyFileErrorException(String message) {
        super(message);
        this.message = message;
    }

    public MyFileErrorException(Throwable cause) {
        super(cause);
    }

    @Override
    public String toString() {
        return message;
    }

    @Override
    public String getMessage() {
        return message;
    }
}

Now I need to throw this exception at will. So in Your case you wantto catch File delete exception so the code will like this -

if(file.delete()) 
      {
      System.out.println(file.getName() + " is deleted!");
      } else {
      try{
            System.out.println("Existing file cannot be deleted.")
            throw new MyFileErrorException("File Could not be deleted val is null");
      }catch(MyFileErrorException ex){

        //Do wahtever you want to do
      }

      } 

At first you should check if any method could throw any specific Exceptions. You could do this by looking into the Javadoc or use your favorite IDE.

If you catch Exception as the Exception class, it catches every Exception that is subclass of it.

If you want to have specific Exception handling, e.g. for an IOException like in the delete() method, you can catch every specific Exceptionclass or use multi-catch in Java 7

try {

    do regular code that can throw exceptions

} catch(Exception e) {
    it catches every Exception that is a subclass of Exception.
    You handle every exception raised in the try block above by the same way
}

If you want to handle exceptions in different ways, e.g. print different messages, just do this like the following example:

try {
    do sth
} catch (SpecificExceptionclass sec) {
    do sth specific for this exception
} catch (AnotherExceptionClass aec) {
    do sth else
}

Or just use Multicatch in Java 7, if you want to have same exception handling for some specific exception classes:

try {
    do sth
} catch (SpecificExceptionclass | AnotherExceptionClass e) {
    do sth specific for this exception
}

To achieve different Exceptions thrown in your code the methods should at least throw different exceptions. In your example with file.exists() and file.delete() there's only an IOException thrown by your code, so there is no use of specific exception handling.

I think it would be a good idea to put your code in a function that returns true or false.

1: True means the file does not exist and was created
2: False means the file exists and was deleted.
3: An exception if the file exists but cant be deleted.

Also provide a separate function to determine if the file exists or not.

Your javadoc at the top of your functions should explain the above so the caller of your functions don't have to look at their content to determine how to use them.

Note an exception is an unusual event and shouldn't be thrown to indicate the state of inserting/deleting. It should be reserved for unusual conditions which the caller normally wouldn't encounter.

A note on exceptions: If you have a large project with 1000 classes each of which has on average 20 functions, that's 20000 functions. Its not practical to pepper each function with excessive exception handling (such as checking for nulls passed in as arguments). A solution to this is to handle checked exceptions in the java language (FileIO) and let (the bulk) of unchecked exceptions ripple up the function call chain until you leave all your business logic and are about to display the results. You only catch them if you want to add additional information to the exception before rethrowing it. Example: adding the primary key value of the record of an SQLExeption being thrown so you know what record is causing problems. Just before you return to the user, log the stack trace and display a simplified message to the user (not the stack trace). The caller of your function should read its javadoc to see how to use it. If he violates your javadoc, the function may or may not throw an exception. Its his reponsibility to follow the javadoc. Last point: your project should have general coding policies for the entire project to prevent some types of exceptions from accidently being introduced by the caller such as: all functions are not epected to recieve nulls as arguments or will return a null unless specified in its javadoc. All functions will accept as arguments (or return) empty lists or empty strings correctly unless specified in their javadoc.