An abstract class in Java can have both abstract and concrete methods, allowing for partial implementation, while an interface can only have abstract methods (prior to Java 8) or default/static methods (from Java 8 onwards). Abstract classes support single inheritance, whereas a class can implement multiple interfaces. Abstract classes are used when there is a shared base implementation, while interfaces define a contract for behavior that multiple classes can implement.

Garbage collection in Java automatically manages memory by reclaiming unused objects. The JVM identifies objects that are no longer referenced by the application and deallocates their memory. The process involves marking reachable objects, sweeping unreachable ones, and optionally compacting memory. Java's garbage collector uses generational collection, dividing the heap into young and old generations to optimize performance. Developers can influence garbage collection behavior using JVM flags but generally rely on the JVM to handle memory management efficiently.

Multithreading in Java allows concurrent execution of two or more threads, enabling efficient use of CPU resources. Threads can be created by extending the Thread class or implementing the Runnable interface. Java provides synchronization mechanisms like synchronized blocks and locks to manage thread safety. The Executor framework simplifies thread management by abstracting thread creation and pooling. Multithreading is essential for tasks like handling multiple client requests or performing background operations without blocking the main application thread.

Java 8 introduced several powerful features, including lambda expressions, which simplify functional programming by enabling concise syntax for anonymous methods. The Stream API allows for efficient processing of collections with operations like filter, map, and reduce. Default methods in interfaces enable backward compatibility by allowing new methods to be added without breaking existing implementations. The Optional class helps handle null values more effectively, reducing the risk of NullPointerException. These features enhance code readability, maintainability, and performance.

In Java, exceptions are handled using try-catch blocks. Code that might throw an exception is placed in the try block, and potential exceptions are caught in the catch block. Checked exceptions must be either caught or declared in the method signature using throws, while unchecked exceptions (runtime exceptions) do not require explicit handling. The finally block is used to execute cleanup code regardless of whether an exception occurs. Proper exception handling ensures robust applications by gracefully managing errors and maintaining application stability.