Debugging Techniques

• Debugging is identifying and rectifying program errors that cause unexpected behavior
• It is a critical and challenging part of programming

Typical Debugging Process:

• Examine error symptoms like crashes, error messages, or unexpected behaviors
• Identify the root cause by tracing the code's execution
• Fix errors by making necessary code changes

Debugging Techniques:

• Understanding the Problem : Fully understand the problem before changing code, reproducing issues is advisable
• Backtracking: Start from the point where the problem began and work backward, useful for complex issues
• Debugging Tools: Use tools like Chrome DevTools, Testsigma, and dbForger for insights into code function, variables, and memory usage
• Breakpoints and Stepping: Set breakpoints to halt execution and inspect functionality, then step through code to study variables/data structures
• Binary Search: Narrow the issue scope using binary search by dividing code into halves
• Rubber Ducking: Explain the problem to someone else (or an object) to force critical thinking
• Log Analysis: Use log analysis statements for debugging
• Clustering Bugs: Group error reports by class to find common patterns, fixing one bug may fix others
• Take Breaks: Stepping away from code helps to clear the mind
• Take Notes: Document the debugging process and solutions

Basic Exception Handling:

• An exception is an unexpected error condition in programming
• Potential exceptions:
  • Attempting to read a non-existent file
  • Attempting to write to a full disk
  • Invalid user input
  • Division by zero
  • Array access with an out-of-bounds index
• Exceptions aren't necessarily "bad"
• Exception handling: Object-oriented techniques to manage or resolve errors
• Runtime error: An unplanned exception during program execution
• Syntax error: An exception found during compilation

Basic Error Classes in Java:

• Error Class: Unrecoverable serious errors
• Exception Class: Recoverable less serious errors, i.e. an invalid array subscript value

Error and Exception Classes:

• The Error and Exception classes descend from the Throwable class
• The Throwable class originates from the Object class.
• Throwable is the superclass for all errors and exceptions in Java

Highlighted Exceptions and Errors:

• IOException: Base class for exceptions when accessing files, directories, and streams
• RuntimeException: Only detected during program execution
• ArithmeticException: Raised during runtime if a math operation is wrong
• IndexOutOfBoundsException: The index used in arrays, lists, or strings is invalid
• ArrayIndexOutOfBoundsException: An array was accessed with an illegal index
• NoSuchElementException: The requested element doesn't exist
• InputMismatchException: The user gives an invalid type of input
• VirtualMachineError: The Java Virtual Machine is broken or out of resources
• OutOfMemoryError: There is insufficient space to allocate an object
• InternalError: An unexpected internal error occurred in the Java Virtual Machine.

Example Java Program

• Sample Division class: Contains a main() method that declares three (3) integers, prompts for values for two, and divides the first two
• Executions can result in:
  • Normal execution with correct inputs
  • ArithmeticException when dividing by zero
  • InputMismatchException with non-integer inputs
• Stack trace history list/stack trace: The list of error messages from each method call during an execution attempt

Try, Catch and Finally Blocks in OOP:

• Methods can "throw" exceptions
• Code blocks can be written to "catch" exceptions

Try Block

• Contains code where errors might occur

Try Block Contents:

• try keyword + curly braces
• Executable statements that might cause exceptions

Catch Block

• Handles thrown exceptions
• Added after a try block
• A throw statement sends an Exception object to be handled elsewhere and caught

Catch Block Structure:

• catch keyword + curly braces
• Exception type and identifier between parentheses
• Actions to take for the error

Method Format with Try-Catch Pair

• Includes optional statements before the try
• Statements generating exceptions within the try block
• catch block actions for exceptions
• Optional statements after the catch block

Catch Block Properties

• A catch block resembles a method named catch() that has an Exception argument
• It isn't a method because it lacks a return type and cannot be called directly
• If the try block throws an exception, the catch block executes, otherwise it does not.
• Any statements after the catch block still execute normally.

Example Application of Try-Catch:

• DivisionMistakeCaught class modifies the Division class
• Provides exception handling for division by zero

Example DivisionMistakeCaught Execution:

• Valid denominator: try block fully executes, bypassing catch block
• Zero denominator: try block is abandoned, ArithmeticException occurs, catch block executes
• "End of program" message displays in both cases

Finally Block:

• Performs actions at the end of try...catch regardless of Exceptions called or caught/not caught
• Usually used for cleanup tasks, must happen whether any Exceptions are thrown.
• Ensures the file is closed before returning to the OS, regardless of try block outcome