[Java] Exception handling

What is exception handling?

• Respond to errors that occur when running the app
• Exception in a narrow sense: An error that cannot be ruled out at the developer's responsibility
• The file does not exist
• The connection destination DB was stopped
• Java must handle these errors
• ** The exception is type (class) **
• ** Represent as a class hierarchy with general exceptions as upper classes and exceptions in individual situations as lower classes **

try ... catch syntax

• ** try block **: Original processing
• ** catch block **: Called by exception type
• Exception thrown = ** Exception thrown **
• Access the exception object via the specified ** exception variable (e or ex) **
• Since the scope is set in block units, the same variable name (e) is OK even if there are multiple catch blocks.
• Exception class methods
• ** getMessage () **: Get error message
• ** getLocalizedMessage () **: Get localized error message
• ** getCause () **: Get the cause of the error
• ** getStackTrace () **: Get stack trace
• ** printStackTrace () **: Stack trace output

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TryBasic {

  public static void main(String[] args) {
    try {
      var in = new FileInputStream("C:/data/nothing.gif");
      var data = -1;
      while ((data = in.read()) != -1) {
        System.out.printf("%02X ", data);
      }
    //Throw a FileNotFoundException exception in the FileInputStream class
    } catch (FileNotFoundException e) {
      System.out.println("The file was not found.");
    } catch (IOException e) {
      //Access the exception object through the specified exception variable (e)
      e.printStackTrace();
    }
  }
}

Stack trace

• ** History of methods before exception occurred **
• Record in the order of calls starting from the main method, which is the entry point.
• Check if an unintended method is called and if the process is wrong

finally block

• The block that will eventually be executed with or without exceptions
• Processing of resources used in try block, etc.
• Finally only one block

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TryFinally {

  public static void main(String[] args) {
    FileInputStream in = null;
    try {
      in = new FileInputStream("C:/data/nothing.gif");
      var data = -1;
      while ((data = in.read()) != -1) {
        System.out.printf("%02X ", data);
      }
    } catch (FileNotFoundException e) {
      System.out.println("The file was not found.");
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      //File close with or without exception
      try {
        if (in != null) {
          in.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}

try-with-resource syntax

• Recommended because it is simpler than the try ... finally syntax
• ** Finally unnecessary because resources are automatically released when the try block is exited! ** **
• Note:
• ** Implement the AutoCloseable interface ** * Reader/Writer/InputStream/OutputStream/Connection/Statement/ResultSet
• ** Resource release order changes **
• In the traditional try ... finally syntax, the resource was alive at the time of the catch block.
• In try-with-resource, resource is released when the try block is exited.
• ** Different resource scope **
• The try ... finally syntax processes resources across blocks, so resource variables are declared outside the try block.
• In try-with-resource, the scope is limited to under the try block (in Java 9 or later, resources declared outside the try block can be cited) * var input = new FileInputStream(...) * try(input){...}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TryWithResources {

//Resource declaration at the beginning of the block
  public static void main(String[] args) {
    try (var in = new FileInputStream("C:/data/hogee.gif")) {
      var data = -1;
      while ((data = in.read()) != -1) {
        System.out.printf("%02X ", data);
      }
    //Automatic resource release when exiting the try block
    } catch (FileNotFoundException e) {
      System.out.println("File not found.");
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Hierarchical structure of exception classes

• From a class hierarchy perspective, all exception / error classes belong to a hierarchical tree with ** Throwable class ** as the apex.
• ** Error class **: Fatal error ---- ** [No exception handling] **
• Subordinate errors are ** error exceptions **
• IOErrer: Serious I / O error, VirtualMachineError: Virtual machine level failure
• ** Exception class ** ‥ ‥ ‥ ‥ ‥ ‥ ‥ ‥ ‥ ‥ ‥ ‥
• ** RuntimeException class ** ---- ** [Exception handling optional] **
• Subordinate errors are ** unchecked exceptions ** (= runtime exceptions)
• IllegalArgumentException: Illegal argument, NullPointerException: Object is null
• Other errors under it are ** inspection exceptions **
• FileNotFoundException: File does not exist, SQLException: Problem when accessing DB

Exception handling notes

• ** Do not catch with Exception **
• catch (Exception e) catches all exceptions
• IOException More specific FileNotFoundException
• ** Utilize multi-catch **
• Do the same for multiple exceptions
• Exception 1 | Exception 2 (in either case)
• ** catch block order **
• If there are multiple, the first description has priority
• ** Write lower exceptions first, higher exceptions later **

//Multi catch
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class TryMulti {

  public static void main(String[] args) {
    try {
      var in = new FileInputStream("C:/data/nasi.gif");
      var data = -1;
      while ((data = in.read()) != -1) {
        System.out.printf("%02X ", data);
      }
      var uri = new URI( "https://www.neko.example.com");
      System.out.println(uri.toString());
    //Multi catch
    } catch (IOException | URISyntaxException e) {
      System.out.println("The file cannot be accessed.");
      e.printStackTrace();
    }
  }
}

Throw an exception

• In addition to throwing the standard library ** Developers can throw **
• You can pass any exception object with `throw exception object'
• ** Declare exceptions that may be thrown in the throws clause **
• throw: throw an exception
• throws: Declared in method / constructor

public FileInputStream(File file) throws FileNotFoundException{
//Abbreviation

Exception throw attention

• ** Do not throw Exception **
• ** Properly select checked / unchecked exceptions **
• Use ** standard exceptions ** as much as possible
• ** NullPointerException **: Object is null
• ** IndexOutOfBoundsException **: Array index out of range
• ** UnsupportedOperationException **: Request operation is not supported
• ** IllegalArgumentException **: Problem with arguments passed to method
• ** IllegalStateException **: Method called when not in intended state
• ** ArithmeticException **: Exceptional condition occurs in calculation
• ** NumberFormatException **: Incorrect number format
• private methods use ** assert instructions **
• AssertionError exception when conditional expression is false
• Works only when the -ea option is specified in the java command

public class AssertBasic {
  private static double getTrapezoidArea(double upper, double lower, double height) {
    //Exception occurs when argument is 0 or less
    assert upper > 0 && lower > 0 && height > 0;
    return (upper + lower) * height / 2;
  }
  public static void main(String[] args) {
    System.out.println(AssertBasic.getTrapezoidArea(-2, 4, 0));
  }
}

Exception rethrow

• Do not process on the spot ** Leave the process to the caller **
• Basically, instead of individual processing on the spot, call individual processing and control the flow of the application ** Should be processed by higher code **
• Exception type can be judged wisely (Java7 ~)
• Only Exception type can be declared with throws
• No need for multi-catch

public class TryRethrow {
//MySampleException,Rethrow method may occur in MyLibException
  public static void rethrow(boolean flag) throws MySampleException, MyLibException {
    try {
      if (flag) {
        throw new MySampleException();
      } else {
        throw new MyLibException();
      }
    //Received as Exception type and thrown again as it is
    } catch (Exception e) {
      throw e;
    }
  }
}

Translation exception

• ** Collect individual exceptions once, bundle them as exceptions of higher-level apps, and re-throw **
• Exceptions can be grouped into app-specific exceptions
• The caller should not be aware of individual exceptions, ** should be aware of higher level exceptions **
• To get the original cause from the translated top exception ** getCause method **
  • var ex = e.getCause();

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Paths;

//You only need to be aware of MySampleException as a translation exception
public class UseTrans {
  public void readHttpPages() throws MySampleException {
    try (var reader = Files.newBufferedReader(Paths.get("C:/data/link.txt"))) {
      var line = "";
      while ((line = reader.readLine()) != null) {
        var client = HttpClient.newHttpClient();
        var req = HttpRequest.newBuilder().uri(URI.create(line)).build();
        var res = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body());
      }
    } catch (IOException | InterruptedException e) {
      throw new MySampleException(e);
    }
  }
}

Proprietary exception class

• Exception class can be defined in the app
• ** Inherit Exception (derived class) **
• ** Overriding the constructor **
• Redefine the constructor defined by Exception and call super OK
• Exceptions with their own field and method implementations are possible

//Inherit Exception (derived class)
public class MySampleException extends Exception {
  //Override constructor
  public MySampleException() {
    super();
  }
  public MySampleException(String message) {
    super(message);
  }
  public MySampleException(String message, Throwable cause) {
    super(message, cause);
  }
  public MySampleException(Throwable cause) {
    super(cause);
  }
}