Core Java OOP and Exception Handling

Key Concepts:
- Classes and Objects: Blueprint (class) to create instances (objects).
- Encapsulation: Bundling data and methods that operate on the data within one unit; usually achieved using access modifiers (private, public).
- Inheritance: Mechanism to create a new class from an existing class (superclass); promotes code reusability.
- Polymorphism: Ability for different classes to be treated as instances of the same class through a common interface. Can be achieved via method overriding and overloading.
- Abstraction: Hiding complex implementation details and showing only the essential features of an object.

Key Components:
- Exceptions: Events that disrupt the normal flow of execution; can be checked (compile-time) or unchecked (runtime).
- try-catch Block: Used to catch exceptions; the code that might throw an exception is placed in the try block, followed by one or more catch blocks to handle exceptions.
- Finally Block: Code within this block executes regardless of whether an exception occurred or was caught; typically used for cleanup.
- Throw vs Throws: throw is used to explicitly throw an exception, while throws is used in method signatures to declare that a method can throw exceptions.

Core Interfaces:
- Collection: Root interface; represents a group of objects.
- List: Ordered collection (e.g., ArrayList, LinkedList); allows duplicates.
- Set: Unordered collection; does not allow duplicates (e.g., HashSet, TreeSet).
- Map: Key-value pairs; keys are unique (e.g., HashMap, TreeMap).
Key Classes:
- ArrayList: Resizable array implementation of the List interface.
- LinkedList: Doubly-linked list implementation of the List interface.
- HashSet: Hash table implementation of the Set interface.
- HashMap: Hash table implementation of the Map interface.
Important Methods:
- add(), remove(), contains(), size(), iterator().

Key Packages:
- java.io: Contains classes for input and output through data streams, serialization, and file handling.
- java.nio: Introduces non-blocking I/O operations and buffers.
Streams:
- Byte Streams: Handle raw binary data (InputStream/OutputStream).
- Character Streams: Handle character data (Reader/Writer).
File Handling:
- File class: Represents file and directory pathnames.
- Common methods include createNewFile(), delete(), exists(), listFiles().

Key Concepts:
- Thread: A lightweight process; allows concurrent execution of code segments.
- Creating Threads:
  - By extending Thread class.
  - By implementing Runnable interface.
- Thread States: New, Runnable, Blocked, Waiting, Timed Waiting, Terminated.
Synchronization:
- Prevents thread interference by using synchronized keyword; can apply to methods or blocks.
- Locks: Provides more advanced control over thread access to resources.
Inter-thread Communication:
- Methods like wait(), notify(), and notifyAll() facilitate communication between threads.
Executor Framework: Simplifies thread management and improves code readability; includes classes like ExecutorService.

These notes provide a concise overview of Core Java's fundamental concepts and components, aiding in effective study and revision.

Classes and Objects: A class serves as a blueprint for creating objects, which are instances of the class.
Encapsulation: Combines data and methods in a single unit, using access modifiers to restrict visibility and enhance security.
Inheritance: Enables a new class (subclass) to inherit properties and behaviors from an existing class (superclass), promoting code reuse and simplifying maintenance.
Polymorphism: Allows entities of different classes to be treated as objects of a common superclass, achieved via method overriding (same method in subclass) and method overloading (same method name with different parameters).
Abstraction: Focuses on exposing essential features while hiding complex implementation details, simplifying user interaction with the object.

Exceptions: Interrupt the normal execution of a program, classified as checked (detected at compile time) or unchecked (detected at runtime).
try-catch Block: Encapsulates code prone to exceptions in a try block and defines how to respond to exceptions in subsequent catch blocks.
Finally Block: Contains cleanup code that executes after the try and catch blocks, ensuring that certain actions are always performed, like releasing resources.
Throw vs Throws: throw indicates an explicit trigger of an exception within a method, while throws is used in method definitions to indicate potential exceptions that may arise during execution.

Core Interfaces:
- Collection: The fundamental interface representing a collection of objects.
- List: An ordered collection that allows for duplicate entries, implemented by classes like ArrayList and LinkedList.
- Set: An unordered collection that does not allow duplicate entries, with implementations like HashSet and TreeSet.
- Map: Represents key-value pairs with unique keys, implemented by classes such as HashMap and TreeMap.
Key Classes:
- ArrayList: A dynamic array that resizes automatically to accommodate new elements.
- LinkedList: A data structure that consists of nodes, each pointing to the next, allowing efficient insertions and deletions.
- HashSet: Implements the Set interface using a hash table, providing constant time performance for basic operations.
- HashMap: A collection that maps keys to values, allowing for quick retrieval based on the unique key.
Important Methods: Common methods for manipulating collections include add(), remove(), contains(), size(), and iterator().

Key Packages:
- java.io: Provides essential classes for handling input and output, file manipulation, and object serialization.
- java.nio: Offers high-performance I/O capabilities with features for non-blocking operations and buffer management.
Streams:
- Byte Streams: Facilitate input and output of binary data, utilizing classes like InputStream and OutputStream.
- Character Streams: Handle character data, employing Reader and Writer classes for easier manipulation of text.
File Handling:
- The File class is crucial for file manipulation—containing methods such as createNewFile(), delete(), exists(), and listFiles() to manage file and directory operations.

Thread: Considered a lightweight process enabling concurrent execution of code segments, enhancing program efficiency.
Creating Threads:
- Can be achieved by extending the Thread class or implementing the Runnable interface.
Thread States: Includes various states such as New, Runnable, Blocked, Waiting, Timed Waiting, and Terminated, describing the lifecycle of a thread.
Synchronization: Utilizes the synchronized keyword to prevent simultaneous access to shared resources, ensuring thread safety.
Locks: Provide more comprehensive control over resource allocation compared to simple synchronization, allowing for better performance in multi-threaded environments.
Inter-thread Communication: Employs methods like wait(), notify(), and notifyAll() to enable communication between threads, facilitating efficient scheduling and resource sharing.
Executor Framework: Offers a simplified approach to thread management, enhancing readability and organization in handling concurrent tasks with classes such as ExecutorService.