Differentiate String and String Buffer class. Explain Exception handling mechanism with an example.

String and StringBuffer are two important classes in Java that are used to manipulate string data. Here are the differences between the two:

1. Immutability: String objects are immutable, meaning that once a String object is created, its value cannot be changed. Any operations that modify a String object actually create a new String object. StringBuffer objects, on the other hand, are mutable, meaning that you can modify their value without creating a new object.
2. Thread safety: String objects are thread-safe, meaning that they can be safely shared across multiple threads. StringBuffer objects are also thread-safe, but they are synchronized, meaning that their use in multi-threaded applications can result in a performance overhead.
3. Performance: When it comes to performance, String objects are faster when used for simple concatenation or comparison operations. However, when you need to perform a large number of modifications on a string, StringBuffer objects can be much faster.

Exception handling is an important concept in Java that allows developers to write robust code that can gracefully handle errors and exceptions that occur during program execution. Here's an example of how exception handling works in Java:

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ExceptionHandlingExample {
    public static void main(String[] args) {

        try {
            File file = new File("example.txt");
            Scanner scanner = new Scanner(file);
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                System.out.println(line);
            }
            scanner.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        }
    }
}

In this example, we try to open a file named "example.txt" and read its contents using a Scanner object. However, if the file doesn't exist, a FileNotFoundException will be thrown. We use a try-catch block to handle this exception. If the exception occurs, the code inside the catch block will be executed, which simply prints an error message to the console. If the exception doesn't occur, the code inside the try block will be executed, which reads the contents of the file and prints them to the console. This way, we can handle the error gracefully and prevent the program from crashing.