Object-oriented Programming and Java Frameworks

Fundamental Concepts:
- Classes and Objects: Class is a blueprint; object is an instance of a class.
- Inheritance: Mechanism to create a new class based on an existing class (superclass).
- Polymorphism: Ability to present the same interface for different underlying data types.
  - Method Overloading: Same method name, different parameters.
  - Method Overriding: Redefining a method in a subclass.
- Encapsulation: Restricting access to certain components of an object; achieved using access modifiers (private, public, protected).
- Abstraction: Hiding complex implementation details and showing only essential features.

Spring Framework:
- Used for building enterprise applications.
- Provides features such as Dependency Injection (DI), Aspect-Oriented Programming (AOP), and MVC architecture.
Hibernate:
- Object-Relational Mapping (ORM) framework.
- Simplifies database interactions by mapping Java objects to database tables.
JavaServer Faces (JSF):
- Framework for building user interfaces for web applications.
- Component-based architecture for reusable UI components.
Apache Struts:
- MVC framework for building web applications.
- Supports the development of large-scale applications.

Overview:
- Framework that provides classes and interfaces for storing and manipulating groups of objects.
Core Interfaces:
- Collection: Root interface; includes List, Set, and Queue.
- List: Ordered collection (e.g., ArrayList, LinkedList).
- Set: Collection that does not allow duplicates (e.g., HashSet, TreeSet).
- Map: Collection of key-value pairs (e.g., HashMap, TreeMap).
Common Methods:
- add(), remove(), contains(), size(), iterator()

Purpose:
- Mechanism to handle runtime errors and maintain normal application flow.
Key Components:
- Try Block: Contains code that may throw exceptions.
- Catch Block: Catches and handles exceptions.
- Finally Block: Executed after try/catch, regardless of exceptions.
- Throw Statement: Used to explicitly throw an exception.
- Throws Clause: Indicates that a method may throw specific exceptions.
Types of Exceptions:
- Checked Exceptions: Compile-time exceptions (e.g., IOException).
- Unchecked Exceptions: Runtime exceptions (e.g., NullPointerException).

Definition:
- Concurrent execution of two or more threads to improve application performance.
Key Concepts:
- Thread: A lightweight subprocess; the smallest unit of processing.
- Creating Threads:
  - Extending Thread class.
  - Implementing Runnable interface.
Thread Lifecycle:
- States: New, Runnable, Blocked, Waiting, Timed Waiting, Terminated.
Synchronization:
- Mechanism to control access to shared resources to prevent data inconsistency.
- Use of synchronized keyword, locks, and concurrent collections.
Inter-thread Communication:
- Using wait(), notify(), and notifyAll() methods to communicate between threads.
Concurrency Utilities:
- java.util.concurrent package provides high-level concurrency utilities (e.g., Executor framework, CountdownLatch).

Classes act as blueprints for objects, which are instances of those classes.
Inheritance allows creation of new classes based on existing classes, establishing a parent-child relationship.
Polymorphism enables methods to perform differently based on the object that invokes them, allowing for method overloading and overriding.
Encapsulation restricts access to certain object components through access modifiers like private, public, and protected.
Abstraction is the process of hiding complex details while exposing essential features to the user.

Spring Framework is designed for enterprise applications and includes features like Dependency Injection (DI), Aspect-Oriented Programming (AOP), and MVC architecture.
Hibernate simplifies database interactions via Object-Relational Mapping (ORM), connecting Java objects to database tables.
JavaServer Faces (JSF) is a component-based framework that facilitates the creation of reusable UI components for web applications.
Apache Struts is an MVC framework that helps in developing large-scale web applications.

Java Collections framework consists of classes and interfaces for grouping and manipulating objects effectively.
The Collection interface is the root of the framework, which includes specialized interfaces like List, Set, and Queue.
List maintains ordered data and includes implementations such as ArrayList and LinkedList.
Set prevents duplicate entries and includes HashSet and TreeSet as common implementations.
Map stores key-value pairs, with popular classes including HashMap and TreeMap.
Common methods in collections include add(), remove(), contains(), size(), and iterator().

Exception handling provides a mechanism for managing runtime errors and ensuring normal application flow.
Try blocks contain code that may generate exceptions, while catch blocks handle these exceptions when they occur.
Finally blocks execute after try/catch operations, regardless of whether an exception was thrown.
The throw statement explicitly triggers an exception, while the throws clause signals that a method can throw specific exceptions.
Exceptions are categorized into checked exceptions, which are encountered at compile-time (e.g., IOException), and unchecked exceptions, which occur at runtime (e.g., NullPointerException).

Multithreading allows multiple threads to run concurrently, enhancing application performance.
A thread is a lightweight subprocess and represents the smallest unit of processing.
Threads can be created by extending the Thread class or implementing the Runnable interface.
The thread lifecycle includes several states: New, Runnable, Blocked, Waiting, Timed Waiting, and Terminated.
Synchronization controls access to shared resources, preventing data inconsistency. It can be achieved through the synchronized keyword and various locking techniques.
Inter-thread communication can be facilitated using methods like wait(), notify(), and notifyAll().
The java.util.concurrent package offers high-level concurrency utilities such as the Executor framework and CountdownLatch for better thread management.