Java is a high-level, object-oriented programming language designed for platform independence and security.

Platform independence, object-oriented, robustness, security, multithreading, and rich API.

JDK (Java Development Kit) is for development, JRE (Java Runtime Environment) is for running applications, and JVM (Java Virtual Machine) executes Java bytecode.

An object is an instance of a class, encapsulating data and behavior.

A class is a blueprint for creating objects, defining attributes and methods.

Inheritance allows one class to inherit the properties and methods of another, promoting code reuse.

Polymorphism allows methods to do different things based on the object calling them, achieved through method overloading and overriding.

An interface defines a contract of methods without implementation. Classes that implement it must provide concrete methods.

Abstract classes can have both abstract and concrete methods and support single inheritance, while interfaces can only have abstract methods and support multiple inheritance.

Java Collections is a framework for storing and manipulating groups of objects, including lists, sets, and maps.

ArrayList provides fast random access and slower insertions, while LinkedList provides faster insertions and deletions but slower access.

Exception handling is a mechanism to handle runtime errors using try, catch, finally, throw, and throws.

A constructor initializes objects when they are created and has the same name as the class.

Static members belong to the class rather than instances and can be accessed without creating an object.

The final keyword restricts modifications: final variables cannot be reassigned, final methods cannot be overridden, and final classes cannot be extended.

Multithreading is the ability of Java to perform multiple tasks concurrently using threads.

JVM is an abstract machine that executes Java bytecode, enabling platform independence.

== compares object references, while equals() compares the content of objects.

Garbage collection automatically reclaims memory by removing objects that are no longer referenced.

The Singleton pattern ensures a class has only one instance and provides a global access point.

Method overloading allows multiple methods with the same name but different parameters in a class.

Method overriding provides a specific implementation of a method in a subclass that already exists in the superclass.

this refers to the current instance of a class and is used to differentiate instance variables from parameters.

An abstract class can have both abstract and concrete methods; an interface can only have abstract methods (prior to Java 8).

Annotations provide metadata about the program and can be used for various purposes, including documentation and compile-time checking.

This statement ensures that resources (like files) are closed automatically after use, improving resource management.

Lambda expressions provide a concise way to represent functional interfaces (single abstract method interfaces) using an expression instead of an implementation.

The Stream API allows processing sequences of elements (like collections) in a functional style, enabling operations like filtering, mapping, and reducing.

ArrayList is not synchronized and is generally faster; Vector is synchronized and thread-safe but slower due to overhead.

The volatile keyword indicates that a variable's value may be changed by different threads, ensuring visibility of changes to the variable across threads.