Java is a popular programming language known for its robust and versatile features. Some of the main features include:

• Object-Oriented: Everything in Java revolves around objects, supporting encapsulation, inheritance, and polymorphism.
• Platform-Independent: Java uses the Java Virtual Machine (JVM) to run compiled code (bytecode) on any platform.
• Simple: Java has a clean and simple syntax that resembles C++, making it easy to learn.
• Secure: Java has built-in security features such as bytecode verification and security managers.
• Robust: With features like garbage collection, exception handling, and memory management, Java ensures reliable applications.
• Multithreaded: Java supports multithreading, allowing concurrent execution of two or more threads.

• Compilation: Java code is compiled into bytecode by the Java Compiler.
• Execution: The JVM interprets this bytecode and executes it on the host machine.
• Key components of JVM:
• Class Loader: Loads class files.
• Bytecode Verifier: Ensures code doesn't perform illegal operations.
• Execution Engine: Executes bytecode.
• JVM also manages memory allocation and garbage collection.

• JDK (Java Development Kit): A development environment containing the Java Compiler, libraries, and tools required for developing Java applications.
• JRE (Java Runtime Environment): A runtime environment that includes JVM and libraries needed to execute Java applications.
• JVM (Java Virtual Machine): Part of JRE, it executes bytecode.

• public: The method is accessible from anywhere.

• static: Allows the method to be invoked without creating an instance of the class.
• void: Indicates the method doesn't return a value.
• main: Entry point of Java applications.
• String[] args: Accepts command-line arguments.

public class Example {

   public static void main(String[] args) {

       System.out.println("Hello, Java!");

   }

}

• Encapsulation: Binding data and methods together.
• Inheritance: Reusing code by creating new classes from existing ones.
• Polymorphism: Performing a single action in different ways.
• Abstraction: Hiding implementation details and exposing only the functionality.
• OOP enhances modularity, scalability, and reusability.

• Abstract Classes: Can have both abstract and concrete methods. Suitable for base classes where default behavior is shared.
• Interfaces: Can only have abstract methods (before Java 8). From Java 8 onwards, they can include default and static methods.
  Use abstract classes when you need partial implementation, and interfaces when you want full abstraction or multiple inheritances.
  
  

• final: Used to declare constants, prevent inheritance, or method overriding.
• finally: A block in exception handling that executes whether an exception occurs or not.
• finalize: A method invoked by the garbage collector before an object is destroyed.

• Heap Memory: Used for objects.
• Stack Memory: Stores method calls and local variables.
• Garbage Collector: Frees memory by removing unreachable objects.
• Developers can also use System.gc() to suggest garbage collection.

• Checked Exceptions: Handled during compile time (e.g., IOException).
• Unchecked Exceptions: Occur during runtime (e.g., NullPointerException).
• Error: Issues like OutOfMemoryError, beyond application control.

• Method Overloading: Methods with the same name but different parameter lists. It allows compile-time polymorphism.
• Method Overriding: Redefining a superclass method in a subclass, enabling runtime polymorphism.
  
  

• Public: Accessible from anywhere.
• Protected: Accessible within the package and subclasses.
• Default: Accessible within the package.
• Private: Accessible only within the class.

• Stream API
• Lambda Expressions
• Optional Class
• Date and Time API

• Compile-time type checking.
• Eliminates the need for typecasting.
• Enhances code readability and maintainability.

• File: Represents a file or directory.
• FileReader/FileWriter: For reading and writing text files.
• BufferedReader/BufferedWriter: For efficient reading/writing of large data.
• FileInputStream/FileOutputStream: For binary data.

Example of reading a file:

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {

    String line;

    while ((line = br.readLine()) != null) {

        System.out.println(line);

    }

}

• Comparable: Used to define the natural ordering of objects. The class must implement the Comparable interface and override the compareTo() method.

• Comparator: Used for custom sorting. You need to implement the Comparator interface and override the compare() method.

• Thread-Safety: HashMap is not synchronized and is faster. HashTable is synchronized and thread-safe.
• Null Keys/Values: HashMap allows one null key and multiple null values. HashTable doesn’t allow null keys or values.
• Performance: HashMap is generally faster due to the lack of synchronization overhead.
• Legacy vs. Modern: HashTable is considered a legacy class, whereas HashMap is part of the Java Collections Framework.

• Checked Exceptions: These are checked at compile-time. They must be declared in the throws clause of the method or handled using a try-catch block. Example: IOException.
• Unchecked Exceptions: These occur at runtime and are not checked at compile-time. Examples include NullPointerException and ArithmeticException.

Both abstract classes and interfaces are used to achieve abstraction in Java, but they serve different purposes:

Abstract Classes:

• Can have both abstract and concrete (implemented) methods.
• Support inheritance, meaning you can extend only one abstract class.
• Can have instance variables and constructors.
• Use the abstract keyword.

Interfaces:

• All methods are abstract (prior to Java 8). From Java 8 onwards, interfaces can have default and static methods.
• Allow multiple inheritance. A class can implement multiple interfaces.
• Variables are implicitly public, static, and final.

• @Override: Indicates that a method overrides a superclass method.
• @Deprecated: Marks a method or class as deprecated.
• @SuppressWarnings: Suppresses specified warnings.