Top 59 Java Interview Questions and Answers

Java is a popular, high-level, object-oriented programming language developed by Sun Microsystems (now owned by Oracle). It was designed with the philosophy "Write Once, Run Anywhere" (WORA), meaning compiled Java code can run on any platform that supports Java without the need for recompilation. This platform independence is achieved through the Java Virtual Machine (JVM).

Key features of Java include:

• Platform Independent: As mentioned, Java code compiled into bytecode can run on any operating system with a JVM.
• Object-Oriented: Java follows the Object-Oriented Programming (OOP) paradigm, which helps in organizing complex programs into reusable software blueprints (classes) and their instances (objects).
• Simple: Java's syntax is relatively easy to learn, especially for programmers familiar with C/C++. It omits many complex features of C++ like explicit pointers and operator overloading.
• Secure: Java provides a secure environment for program execution. It uses a security manager to define access policies for applications and includes features like bytecode verification to ensure integrity.
• Robust: Java emphasizes error checking at both compile time and runtime. It has strong memory management (garbage collection) and exception handling mechanisms, making it less prone to common programming errors.
• Multithreaded: Java supports multithreading, allowing multiple parts of a program to execute concurrently, leading to better performance and responsiveness in applications.
• High Performance: While interpreted, Java's use of Just-In-Time (JIT) compilers within the JVM optimizes bytecode execution, often approaching native code performance.
• Distributed: Java is designed to work in distributed environments, allowing applications to be built across multiple networks, which is fundamental for internet applications.

Understanding the differences between JVM, JRE, and JDK is fundamental to grasping how Java applications are developed and executed.

• JVM (Java Virtual Machine): The JVM is an abstract machine that provides a runtime environment for executing Java bytecode. It's the core component that enables Java's "Write Once, Run Anywhere" capability. When you run a Java program, the JVM loads the .class files, verifies the bytecode, executes it, and manages runtime memory. The JVM is specific to each operating system; for example, there's a different JVM implementation for Windows, macOS, and Linux.

• JRE (Java Runtime Environment): The JRE is a software package that provides the necessary libraries, classes, and other files required to run Java applications. It includes the JVM and a set of standard class libraries (like the Java API). If you only want to run Java applications and not develop them, you only need the JRE. It does not contain development tools like compilers or debuggers.

• JDK (Java Development Kit): The JDK is a complete software development kit for Java. It contains everything needed to develop, compile, debug, and run Java applications. The JDK includes the JRE, along with development tools such as the Java compiler (javac), the Java debugger (jdb), and documentation tools (javadoc). Developers install the JDK to write and compile Java code.

In summary, the JVM is the specification and runtime engine, the JRE is the environment to run Java applications (JVM + libraries), and the JDK is the full development package (JRE + development tools). To run a Java program, you need JRE; to develop one, you need JDK.

Object-Oriented Programming (OOP) is a programming paradigm that structures programs around objects rather than actions and data rather than logic. The four main pillars of OOP in Java are Encapsulation, Inheritance, Polymorphism, and Abstraction.

1. Encapsulation: This is the mechanism of bundling data (attributes) and methods (functions) that operate on the data within a single unit, i.e., a class. It also involves restricting direct access to some of an object's components, typically achieved through access modifiers like private. Encapsulation helps in data hiding, meaning the internal state of an object is hidden from the outside world, and interactions occur only through well-defined public methods.

   class BankAccount {
       private double balance; // Data is private
   
       public BankAccount(double initialBalance) {
           this.balance = initialBalance;
       }
   
       public void deposit(double amount) { // Public method to access/modify data
           if (amount > 0) {
               this.balance += amount;
           }
       }
   
       public double getBalance() { // Public method to read data
           return balance;
       }
   }
   

2. Inheritance: Inheritance is a mechanism where one class acquires the properties and behaviors (fields and methods) of another class. The class that is inherited is called the superclass (or parent class), and the class that inherits is called the subclass (or child class). It promotes code reusability and establishes an "is-a" relationship between classes.

   class Animal { // Superclass
       void eat() {
           System.out.println("Animal is eating");
       }
   }
   
   class Dog extends Animal { // Subclass inherits from Animal
       void bark() {
           System.out.println("Dog is barking");
       }
   }
   

3. Polymorphism: Meaning "many forms," polymorphism allows objects to be treated as instances of their parent class rather than their actual class. It enables a single interface to represent different underlying forms. In Java, polymorphism is primarily achieved through method overriding (runtime polymorphism) and method overloading (compile-time polymorphism).

   class Vehicle {
       void drive() {
           System.out.println("Vehicle is driving");
       }
   }
   
   class Car extends Vehicle {
       @Override
       void drive() { // Method overriding
           System.out.println("Car is driving");
       }
   }
   
   class Motorcycle extends Vehicle {
       @Override
       void drive() { // Method overriding
           System.out.println("Motorcycle is driving");
       }
   }
   
   // In main:
   // Vehicle myVehicle = new Car();
   // myVehicle.drive(); // Calls Car's drive()
   

4. Abstraction: Abstraction is the concept of hiding the complex implementation details and showing only the essential features of an object to the outside world. It focuses on "what" an object does rather than "how" it does it. In Java, abstraction is achieved using abstract classes and interfaces.

   abstract class Shape { // Abstract class
       abstract double calculateArea(); // Abstract method (no implementation)
   
       void display() {
           System.out.println("This is a shape.");
       }
   }
   
   class Circle extends Shape {
       double radius;
   
       public Circle(double radius) {
           this.radius = radius;
       }
   
       @Override
       double calculateArea() { // Provides implementation for abstract method
           return Math.PI * radius * radius;
       }
   }
   

   Abstraction helps manage complexity by presenting a simplified view of functionality.

Both interface and abstract class are used to achieve abstraction in Java, allowing you to define a contract for classes that implement or extend them. However, they serve different purposes and have distinct characteristics:

• Multiple Inheritance: A class can implement multiple interfaces, but it can extend only one abstract class (or any class). This is a fundamental difference as Java does not support multiple inheritance of classes to avoid the "diamond problem."

• Methods:

  • Abstract Class: Can have abstract (unimplemented) methods and concrete (implemented) methods. Since Java 8, it can also have static and default methods.
  • Interface: Before Java 8, all methods in an interface were implicitly public and abstract. Since Java 8, interfaces can have default and static methods with implementations, and since Java 9, they can also have private methods.

• Variables (Fields):

  • Abstract Class: Can have instance variables (non-final, non-static) and static variables (non-final) which can be of any access modifier. They can hold state.
  • Interface: All variables in an interface are implicitly public, static, and final (constants). They cannot hold instance state, only constants.

• Constructors:

  • Abstract Class: Can have constructors. These are called by the constructor of the concrete subclass using super().
  • Interface: Cannot have constructors because they cannot be instantiated directly and do not maintain state.

• Access Modifiers:

  • Abstract Class: Methods and variables can have any access modifier (public, protected, private, default).
  • Interface: Before Java 9, all methods were implicitly public. All variables are implicitly public static final.

• Relationship:

  • Abstract Class: Represents an "is-a" relationship where a subclass is a type of superclass. It's suitable for providing a base class with some common behavior and structure for a hierarchy of related classes.
  • Interface: Represents a "has-a capability" or "can-do" relationship. It defines a contract that unrelated classes can agree to implement, promoting polymorphism across different class hierarchies.

• Instantiation: Neither abstract classes nor interfaces can be instantiated directly using the new keyword. They must be extended or implemented by a concrete class.

The final keyword in Java is a non-access modifier used to restrict a class, method, or variable. It essentially makes the entity immutable or non-overrideable/non-inheritable, depending on its context.

1. final Variable: When final is applied to a variable, its value can be assigned only once. Once assigned, it cannot be changed. This makes it a constant. If it's a primitive type, its value is constant. If it's an object reference, the reference itself is constant (it will always point to the same object), but the contents of the object it refers to can still be modified.

   public class FinalVariableExample {
       final int SPEED_LIMIT = 90; // A final primitive variable (constant)
       final String NAME; // Can be assigned in constructor or initializer block
   
       public FinalVariableExample() {
           NAME = "Java";
       }
   
       public void tryToChange() {
           // SPEED_LIMIT = 100; // Compile-time error: cannot assign a value to final variable
           System.out.println("Speed Limit: " + SPEED_LIMIT + ", Name: " + NAME);
       }
   
       final StringBuilder builder = new StringBuilder("Initial");
   
       public void modifyObjectContent() {
           // builder = new StringBuilder("New"); // Compile-time error: final reference cannot be reassigned
           builder.append(" Appended"); // Valid: content of the object can be modified
           System.out.println("Builder content: " + builder);
       }
   }
   

2. final Method: When final is applied to a method, it means that the method cannot be overridden by any subclass. This ensures that the implementation of that method remains consistent across all inheriting classes, preventing subclasses from changing its behavior.

   class Parent {
       final void display() {
           System.out.println("This is a final method in Parent.");
       }
   
       void regularMethod() {
           System.out.println("Regular method in Parent.");
       }
   }
   
   class Child extends Parent {
       // void display() { // Compile-time error: cannot override final method from Parent
       //     System.out.println("This method cannot be overridden.");
       // }
   
       @Override
       void regularMethod() {
           System.out.println("Regular method overridden in Child.");
       }
   }
   

3. final Class: When final is applied to a class, it means that the class cannot be subclassed or inherited. This prevents other classes from extending it. This is often used for security reasons, or when the design guarantees the class's behavior and internal state are not meant to be modified or extended, such as with immutable classes like String in Java.

   final class ImmutableClass {
       private final String data;
   
       public ImmutableClass(String data) {
           this.data = data;
       }
   
       public String getData() {
           return data;
       }
   }
   
   // class AnotherClass extends ImmutableClass { // Compile-time error: cannot inherit from final class
   //     // ...
   // }
   

   The final keyword is crucial for designing robust and secure applications by enforcing immutability and preventing unintended modifications or extensions.

Exception handling in Java is a powerful mechanism to manage runtime errors and ensure that the program can recover gracefully or terminate predictably. An exception is an event that disrupts the normal flow of a program. Java's exception handling uses five keywords: try, catch, finally, throw, and throws.

• try block: This block encloses the code segment that might throw an exception. If an exception occurs within the try block, the normal flow of execution is interrupted, and control is transferred to an appropriate catch block.

  try {
      // Code that might throw an exception
      int result = 10 / 0; // This will throw ArithmeticException
  } 
  // ...
  

• catch block: This block immediately follows a try block and is used to handle a specific type of exception that might be thrown by the try block. If an exception of the specified type (or its subclass) occurs, the code inside the catch block is executed, allowing the program to respond to the error, log it, or recover.

  try {
      int result = 10 / 0;
  } catch (ArithmeticException e) {
      System.err.println("Error: Division by zero is not allowed. " + e.getMessage());
  } catch (Exception e) { // Generic catch for any other exception
      System.err.println("An unexpected error occurred: " + e.getMessage());
  }
  

• finally block: This block is always executed, regardless of whether an exception occurred in the try block or was caught by a catch block. It's typically used for cleanup operations, such as closing files, database connections, or releasing system resources, to ensure they are properly managed even in the event of an error.

  try {
      // Open a resource, e.g., FileOutputStream
      int result = 10 / 2; // No exception
  } catch (ArithmeticException e) {
      System.err.println("Error: " + e.getMessage());
  } finally {
      System.out.println("Finally block executed. Resource cleanup here.");
      // Close the resource
  }
  

• throw keyword: The throw keyword is used to explicitly throw an exception from any part of the code. This is useful for signaling an error condition when a specific situation occurs that the program cannot handle. It can throw both checked and unchecked exceptions.

  public void validateAge(int age) {
      if (age < 0 || age > 120) {
          throw new IllegalArgumentException("Age must be between 0 and 120.");
      }
      System.out.println("Age is valid.");
  }
  

• throws keyword: The throws keyword is used in a method signature to declare that a method might throw one or more specified types of checked exceptions. It informs the caller that they must either handle these exceptions using try-catch or re-declare them in their own method signature using throws.

  import java.io.IOException;
  import java.io.FileReader;
  
  public class FileReaderExample {
      public void readFile(String filePath) throws IOException {
          FileReader reader = new FileReader(filePath); // FileReader constructor can throw IOException
          // ... read from reader ...
          reader.close(); // close() can also throw IOException
      }
  
      public static void main(String[] args) {
          FileReaderExample example = new FileReaderExample();
          try {
              example.readFile("nonExistentFile.txt");
          } catch (IOException e) {
              System.err.println("Could not read file: " + e.getMessage());
          }
      }
  }
  

  Java distinguishes between checked exceptions (must be declared or caught, like IOException) and unchecked exceptions (runtime exceptions, like NullPointerException or ArithmeticException, which don't need explicit handling).

Generics in Java are a powerful feature introduced in Java 5 that allows types (classes and interfaces) to be parameters when defining classes, interfaces, and methods. Just like method parameters, type parameters enable you to create classes, interfaces, and methods that operate on different types of objects while maintaining type safety.

Why are Generics Used?

1. Type Safety: Generics enforce type checking at compile time. This means that if you try to put the wrong type of object into a generic collection, the compiler will catch the error, preventing ClassCastException at runtime. Without generics, you might encounter such errors, which are harder to debug.
2. Elimination of Type Casting: When working with collections without generics, every object retrieved from the collection is of type Object, requiring you to explicitly cast it back to its original type. Generics eliminate the need for these explicit casts, making code cleaner and less error-prone.
3. Code Reusability: Generics allow you to write algorithms and data structures that work on different types of objects without having to duplicate code. You can define a generic class once, and it will work for any specified type.

Example:

Consider a simple Box class that can hold any type of object. Without generics, you would store an Object:

// Without Generics (pre-Java 5 style)
class BoxWithoutGenerics {
    private Object item;

    public void setItem(Object item) {
        this.item = item;
    }

    public Object getItem() {
        return item;
    }
}

// Usage:
// BoxWithoutGenerics box = new BoxWithoutGenerics();
// box.setItem(10); // Stores an Integer as Object
// String myString = (String) box.getItem(); // Runtime error! ClassCastException

With generics, you specify the type at the time of instantiation:

// With Generics
class Box<T> { // T is a type parameter
    private T item; // The item can be of type T

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

public class GenericExample {
    public static void main(String[] args) {
        // Create a Box to hold Integer
        Box<Integer> integerBox = new Box<>();
        integerBox.setItem(10);
        // integerBox.setItem("Hello"); // Compile-time error! Type mismatch
        Integer value = integerBox.getItem(); // No casting needed
        System.out.println("Integer value: " + value);

        // Create a Box to hold String
        Box<String> stringBox = new Box<>();
        stringBox.setItem("Hello Generics");
        String text = stringBox.getItem(); // No casting needed
        System.out.println("String value: " + text);
    }
}

In this generic Box<T> example, T is a type parameter. When you create Box<Integer>, T becomes Integer, and the compiler ensures that only Integer objects are stored and retrieved, providing compile-time type safety and eliminating the need for manual type casting.

The Java Collections Framework (JCF) is a unified architecture for representing and manipulating collections (groups of objects). It provides a set of interfaces and classes that enable developers to store, retrieve, manipulate, and communicate aggregate data efficiently. The JCF is designed to be highly flexible, extensible, and performant.

Core Benefits of JCF:

• Reduced Development Effort: Provides ready-to-use data structures and algorithms.
• Increased Performance: Optimized implementations for various common operations.
• Interoperability: Standardized interfaces allow different implementations to work together.
• Code Reusability: Algorithms can be applied to diverse types of collections.

Core Interfaces and their Typical Implementations:

The JCF is built around a set of core interfaces, each defining a specific type of collection. These interfaces are then implemented by various concrete classes.

1. Collection Interface: This is the root interface of the collection hierarchy. It defines the basic operations that all collections should support, such as add(), remove(), contains(), isEmpty(), and size(). Collection itself is not directly implemented but provides a foundation for more specific sub-interfaces.

2. List Interface:

   • Represents an ordered sequence of elements (like a dynamic array). Elements can be accessed by their integer index. Lists allow duplicate elements.
   • Typical Implementations:
     • ArrayList: Resizable array implementation. Good for fast random access (getting elements by index) but slower for insertions/deletions in the middle of the list.
     • LinkedList: Doubly-linked list implementation. Efficient for insertions and deletions from the middle or ends of the list but slower for random access.
     • Vector: Similar to ArrayList but synchronized (thread-safe), making it generally slower for single-threaded applications.

3. Set Interface:

   • Represents a collection that does not allow duplicate elements. It models the mathematical set abstraction. Sets are unordered (though some implementations might maintain an order).
   • Typical Implementations:
     • HashSet: Uses a hash table for storage. Offers constant-time performance (O(1)) for basic operations like add(), remove(), contains(), assuming a good hash function. Does not guarantee iteration order.
     • LinkedHashSet: A hash table and linked list implementation. Maintains insertion order of elements.
     • TreeSet: Stores elements in a sorted order (either natural order or by a custom Comparator). Provides O(log n) time cost for basic operations due to its tree structure.

4. Map Interface:

   • Represents a collection that maps keys to values. Each key must be unique, and it maps to exactly one value. Map is not a subtype of Collection but is considered part of the JCF.
   • Typical Implementations:
     • HashMap: Uses a hash table. Provides O(1) average-case performance for get() and put() operations. Does not guarantee order.
     • LinkedHashMap: A hash table and linked list implementation. Maintains insertion order of key-value pairs.
     • TreeMap: Stores key-value pairs in a sorted order based on the keys (natural order or custom Comparator). Provides O(log n) time cost for operations.
     • Hashtable: Similar to HashMap but synchronized and does not allow null keys or values.

5. Queue Interface:

   • Represents a collection designed for holding elements prior to processing, typically in a FIFO (First-In, First-Out) manner. It supports insertion at the end and retrieval from the beginning.
   • Typical Implementations:
     • LinkedList: Can implement Queue (and Deque) functionalities.
     • PriorityQueue: Elements are ordered according to their natural ordering or by a Comparator. Retrieves the element with the highest priority (smallest value) first, not necessarily FIFO.
     • ArrayDeque: Implements a double-ended queue (Deque), allowing elements to be added or removed from both ends.

In addition to these interfaces, the JCF also includes Iterator for traversing collections, Comparator and Comparable for sorting, and various utility classes like Collections and Arrays for manipulating collections.

Multithreading in Java is the ability of a program to execute multiple parts of code concurrently within the same process. Each independent path of execution is called a thread. While a program typically starts with a single thread (the main thread), multithreading allows creating additional threads to perform tasks in parallel. This is particularly useful for improving the responsiveness of applications, making efficient use of CPU resources on multi-core processors, and handling multiple user requests simultaneously in server applications.

Advantages of Multithreading:

• Improved Responsiveness: A long-running task can execute in a separate thread, allowing the main application thread to remain responsive to user input.
• Efficient Resource Utilization: On multi-core systems, threads can run on different cores, truly executing in parallel and utilizing hardware resources more effectively.
• Better Performance: Complex tasks can be broken down into smaller sub-tasks that run concurrently, potentially reducing overall execution time.
• Resource Sharing: Threads within the same process share the same memory space, making it easy to share data, although this also introduces challenges like race conditions and synchronization issues.

How to Create a Thread in Java:

Java provides two primary ways to create a thread:

1. By Extending the java.lang.Thread Class: You can create a new class that extends the Thread class and override its run() method. The run() method contains the code that the new thread will execute. To start the thread, you create an instance of your custom thread class and call its start() method. The start() method internally calls the run() method in a new execution thread.

   class MyThread extends Thread {
       @Override
       public void run() {
           for (int i = 0; i < 5; i++) {
               System.out.println(Thread.currentThread().getName() + ": " + i);
               try {
                   Thread.sleep(100); // Simulate some work
               } catch (InterruptedException e) {
                   Thread.currentThread().interrupt();
                   System.out.println(Thread.currentThread().getName() + " interrupted.");
               }
           }
       }
   }
   
   public class ThreadExample1 {
       public static void main(String[] args) {
           MyThread thread1 = new MyThread();
           thread1.setName("Thread-A");
           MyThread thread2 = new MyThread();
           thread2.setName("Thread-B");
   
           thread1.start(); // Invokes run() method on a new thread
           thread2.start(); // Invokes run() method on another new thread
       }
   }
   

2. By Implementing the java.lang.Runnable Interface: This is generally the preferred approach because it allows your class to still extend another class if needed (Java does not support multiple inheritance). You create a class that implements the Runnable interface and define the thread's execution logic within its run() method. Then, you create an instance of your Runnable class and pass it to the constructor of a Thread object. Finally, call the start() method on the Thread object.

   class MyRunnable implements Runnable {
       private String threadName;
   
       public MyRunnable(String name) {
           this.threadName = name;
       }
   
       @Override
       public void run() {
           for (int i = 0; i < 5; i++) {
               System.out.println(threadName + ": " + i);
               try {
                   Thread.sleep(150);
               } catch (InterruptedException e) {
                   Thread.currentThread().interrupt();
                   System.out.println(threadName + " interrupted.");
               }
           }
       }
   }
   
   public class ThreadExample2 {
       public static void main(String[] args) {
           Thread thread1 = new Thread(new MyRunnable("Runnable-X"));
           Thread thread2 = new Thread(new MyRunnable("Runnable-Y"));
   
           thread1.start();
           thread2.start();
       }
   }
   

After calling start(), the JVM calls the run() method on the newly created thread. It's important never to call run() directly, as that would execute the code in the current thread, not a new thread.

Java categorizes data types into two main groups:

• Primitive Data Types:
  • Represent basic values directly in memory.
  • Fixed size and store the actual value.
  • Examples: byte, short, int, long, float, double, boolean, char.

  • int age = 30;
    boolean isActive = true;
    char initial = 'J';
    

• Non-Primitive (Reference) Data Types:
  • Do not store the actual value directly but store a reference (memory address) to the object.
  • Size is not fixed.
  • Examples: String, Arrays, Classes, Interfaces.

  • String name = "Java";
    int[] numbers = {1, 2, 3};
    MyClass obj = new MyClass();
    

Java achieves platform independence through the Java Virtual Machine (JVM).

• Write Once, Run Anywhere (WORA): Java source code (.java files) is compiled into bytecode (.class files), not machine-specific code.
• JVM's Role: The JVM acts as a runtime environment that interprets and executes this bytecode on any underlying operating system or hardware.
• Portability: As long as a compatible JVM is available for a given platform, the same Java bytecode can run without modification.
• This abstraction layer prevents Java programs from being tied to a specific OS, unlike languages that compile directly to native machine code.

The main method is the entry point for any standalone Java application. When you run a Java program, the JVM looks for this method to start execution.

• Signature: public static void main(String[] args)
  • public: An access modifier allowing the JVM to invoke it from anywhere.
  • static: Allows the main method to be called without creating an object of the class. It belongs to the class itself.
  • void: Indicates that the main method does not return any value.
  • main: The fixed name of the method that the JVM recognizes as the entry point.
  • String[] args: An array of String objects, used to accept command-line arguments passed to the program.
• Example:

  public class MyProgram {
      public static void main(String[] args) {
          System.out.println("Hello, Java!");
          if (args.length > 0) {
              System.out.println("First argument: " + args[0]);
          }
      }
  }
  

Both are used for comparison, but they operate differently:

• == Operator:
  • Used for primitive types: Compares the actual values.
  • Used for object types: Compares the memory addresses (references) of the objects. It checks if both references point to the exact same object in memory.

  • int a = 10, b = 10, c = 20;
    System.out.println(a == b); // true (values are equal)
    String s1 = new String("hello");
    String s2 = new String("hello");
    String s3 = s1;
    System.out.println(s1 == s2); // false (different objects in memory)
    System.out.println(s1 == s3); // true (same object reference)
    

• equals() Method:
  • A method defined in the Object class, which can be overridden by subclasses.
  • For objects: By default, Object.equals() behaves like == (compares references).
  • When overridden (e.g., in String, Integer, wrapper classes, and custom classes), it compares the contents or logical equivalence of two objects.

  • String s1 = new String("hello");
    String s2 = new String("hello");
    System.out.println(s1.equals(s2)); // true (String class overrides equals to compare content)
    

• Key Difference: == checks for reference equality (same object), while equals() (if properly overridden) checks for content/value equality (logically equivalent objects).

The static keyword indicates that a member (variable, method, or block) belongs to the class itself, rather than to any specific instance of that class.

• Static Variables (Class Variables):
  • Shared by all instances of the class.
  • Loaded into memory when the class is loaded.
  • Accessed directly using the class name (e.g., ClassName.variableName).

  • class Counter {
        static int count = 0; // Shared across all Counter objects
        Counter() { count++; }
    }
    // Access: Counter.count
    

• Static Methods (Class Methods):
  • Can be called without creating an object of the class.
  • Cannot access non-static (instance) variables or methods directly because they don't operate on a specific object.
  • Often used for utility functions (e.g., Math.max()).

  • class Calculator {
        static int add(int a, int b) {
            return a + b;
        }
    }
    // Call: Calculator.add(5, 3)
    

• Static Blocks (Static Initializer):
  • Used to initialize static variables or perform one-time setup tasks when the class is first loaded into memory.
  • Executed only once.

  • class AppConfig {
        static String DB_URL;
        static {
            DB_URL = "jdbc:mysql://localhost:3306/mydb";
            System.out.println("DB_URL initialized.");
        }
    }
    

• Static Nested Classes: Can be defined within another class. They don't require an outer class instance.

These are two distinct forms of polymorphism in Java:

• Method Overloading (Compile-Time Polymorphism):
  • Occurs within a single class.
  • Allows multiple methods with the same name but different signatures (different number, type, or order of parameters).
  • Return type can be different but is not sufficient to overload a method alone.
  • The compiler decides which overloaded method to call based on the arguments provided at compile time.

  • class Calculator {
        int add(int a, int b) { return a + b; }
        double add(double a, double b) { return a + b; }
        int add(int a, int b, int c) { return a + b + c; }
    }
    

• Method Overriding (Run-Time Polymorphism):
  • Occurs between a superclass and a subclass.
  • Allows a subclass to provide a specific implementation for a method that is already defined in its superclass.
  • The method in the subclass must have the exact same signature (name, parameters, and return type) as the method in the superclass.
  • The @Override annotation is optional but good practice.
  • The JVM determines which version of the method (superclass or subclass) to execute at run time based on the actual object type.

  • class Animal {
        void makeSound() { System.out.println("Animal makes a sound"); }
    }
    class Dog extends Animal {
        @Override
        void makeSound() { System.out.println("Dog barks"); }
    }
    Animal myDog = new Dog();
    myDog.makeSound(); // Output: Dog barks
    

Access modifiers control the visibility and accessibility of classes, fields, methods, and constructors.

• public:
  • Accessible from anywhere: within the same class, same package, subclasses, and outside the package.
  • Widest scope.

  • public class PublicClass {
        public int publicVar;
    }
    

• protected:
  • Accessible within the same package and by subclasses (even if in a different package).

  • package com.example.model;
    public class Parent {
        protected int protectedVar;
    }
    package com.example.sub;
    class Child extends Parent {
        // Can access protectedVar
    }
    

• default (no keyword / package-private):
  • Accessible only within the same package.
  • If no access modifier is specified, this is the default.

  • // In package com.example.util
    class DefaultClass {
        int defaultVar; // Accessible only within com.example.util
    }
    

• private:
  • Accessible only within the same class where it is declared.
  • Most restrictive scope.
  • Often used for encapsulation to hide internal implementation details.

  • public class MyClass {
        private String secretData;
        private void secretMethod() { /* ... */ }
    }
    

String immutability means that once a String object is created, its content cannot be changed.

• How it works: Any operation that appears to modify a String (e.g., concatenation, toUpperCase()) actually creates a new String object with the modified content, leaving the original String unchanged.

  String s = "Hello";
  s.concat(" World"); // s still refers to "Hello"
  System.out.println(s); // Output: Hello
  String newS = s.concat(" World"); // newS refers to "Hello World"
  System.out.println(newS); // Output: Hello World
  

• Reasons for immutability:
  • Security: Strings are frequently used to store sensitive information (usernames, passwords, file paths). Immutability prevents accidental or malicious alteration of these values.
  • Thread Safety: Immutable objects can be safely shared among multiple threads without synchronization, simplifying concurrent programming.
  • Performance/Caching: String literals are stored in the String Pool (a special memory area in the heap). Immutability allows Java to optimize by reusing existing String objects instead of creating new ones for identical string literals.
  • Hash Code Caching: An immutable String's hashCode() can be computed once and cached, improving performance when used as keys in HashMap or HashSet.

The hashCode() method returns an integer hash code value for an object.

• Purpose: Primarily used in hash-based collections like HashMap, HashSet, and Hashtable.
  • When an object is stored in such a collection, its hashCode() is used to quickly determine the bucket or index where it should be placed.
  • This speeds up object retrieval: first, the hash code narrows down the search, then equals() is used to find the exact object within that bucket.
• Contract between equals() and hashCode(): The Object class defines a crucial contract:
  1. If two objects are equal according to the equals(Object) method, then calling the hashCode() method on each of the two objects must produce the same integer result.
  2. If two objects have the same hash code, they are not necessarily equal (hash collisions can occur).
  3. If two objects have different hash codes, they are definitely not equal.
• Why Override Together: If you override equals() without overriding hashCode(), you violate this contract:
  • Two logically equal objects (as per your equals() logic) might produce different hash codes (default Object.hashCode() often generates a unique code per object).
  • This leads to serious issues in hash-based collections: an equal object might not be found or retrieved because it's stored in a different bucket than where get() would look based on its hash code. You could put an object but fail to get it using an equal object.

Java exclusively uses pass by value for all arguments passed to methods.

• Pass By Value:
  • A copy of the actual argument's value is passed to the method's parameter.
  • Any changes made to the parameter inside the method will only affect that copy and will not modify the original argument.
• How it applies to Primitives:
  • For primitive data types (e.g., int, double, char), the actual value is copied.

  • void changeValue(int num) { num = 20; }
    int x = 10;
    changeValue(x);
    System.out.println(x); // Output: 10 (x remains unchanged)
    

• How it applies to Objects (References):
  • For objects, the value of the reference (memory address) is copied.
  • The method now has a copy of the reference, pointing to the same object in memory as the original argument.
  • Changes made to the object's state (its fields) using this copied reference will affect the original object.
  • However, if you reassign the parameter reference itself to point to a new object inside the method, the original reference remains unchanged.

  • class MyObject { int value = 0; }
    void changeObject(MyObject obj) {
        obj.value = 100; // Changes the original object's state
        obj = new MyObject(); // Reassigns local 'obj' reference
        obj.value = 200; // Affects the NEW object, not the original
    }
    MyObject myObj = new MyObject();
    changeObject(myObj);
    System.out.println(myObj.value); // Output: 100 (original object's state was modified)
    

• Conclusion: Since Java always passes a copy of the value (either a primitive value or a reference value), it is pass by value.

Garbage Collection (GC) is an automatic memory management process in Java.

• Purpose: It automatically identifies and reclaims memory occupied by objects that are no longer referenced by the program, preventing memory leaks and managing the heap.
• How it Works (General Steps):
  1. Marking: The GC algorithm traverses the object graph, starting from garbage collection roots (e.g., active threads, static variables). It marks all reachable objects as 'live'.
  2. Sweeping: After marking, the GC iterates through the heap and deletes (sweeps) all objects that were not marked as live. Their memory space is made available for new object allocations.
  3. Compacting (Optional): To reduce memory fragmentation, some GC algorithms (e.g., G1 GC) perform compaction, relocating live objects to contiguous blocks of memory.
• Generational Hypothesis: Most modern GCs use a generational approach:
  • The heap is divided into Young Generation (for new, short-lived objects) and Old Generation (for long-lived objects).
  • Minor GC: Collects garbage in the Young Generation frequently. Most objects die young.
  • Major/Full GC: Collects garbage across the entire heap (Young and Old Generations) less frequently.
• Automatic Process: Developers don't explicitly free memory; the JVM handles it. You can suggest a GC run using System.gc() or Runtime.getRuntime().gc(), but there's no guarantee it will execute immediately.

Both ArrayList and LinkedList implement the List interface but differ significantly in their underlying data structures and performance characteristics.

• ArrayList:
  • Data Structure: Uses a dynamic array internally.
  • Storage: Stores elements in contiguous memory locations.
  • Access: Fast random access (e.g., get(index)) due to direct index calculation (O(1)).
  • Insertion/Deletion: Slow for insertions or deletions in the middle of the list (O(n)) because it requires shifting subsequent elements.
  • Memory: Can waste memory if capacity isn't managed well; requires resizing (creating a new, larger array and copying elements) when full.

  • ArrayList<String> names = new ArrayList<>();
    names.add("Alice");
    names.get(0); // Fast access
    

• LinkedList:
  • Data Structure: Uses a doubly-linked list internally.
  • Storage: Each element (node) stores the data, a reference to the next node, and a reference to the previous node. Elements are not stored contiguously.
  • Access: Slow random access (get(index)) because it requires traversing the list from the beginning or end (O(n)).
  • Insertion/Deletion: Fast for insertions or deletions at any position (O(1)) once the insertion point is found, as it only involves updating a few references.
  • Memory: Higher memory overhead per element due to storing two references (next and previous).

  • LinkedList<String> tasks = new LinkedList<>();
    tasks.addFirst("Task A"); // Fast insertion at beginning/end
    tasks.removeLast();
    

• When to Use: Choose ArrayList for frequent random access and less frequent modifications in the middle. Choose LinkedList for frequent insertions/deletions, especially at the ends, and sequential access.

Autoboxing and Unboxing are features introduced in Java 5 to automatically convert between primitive types and their corresponding wrapper classes.

• Autoboxing:
  • The automatic conversion of a primitive type to its corresponding wrapper class object.
  • Happens implicitly when a primitive value is used where an object of its wrapper class is expected.

  • int primitiveInt = 10;
    Integer wrapperInt = primitiveInt; // Autoboxing: int to Integer
    System.out.println(wrapperInt); // Output: 10
    
    // Example in method call
    void processInteger(Integer i) { /* ... */ }
    processInteger(100); // 100 (int) is autoboxed to Integer
    

• Unboxing:
  • The automatic conversion of a wrapper class object to its corresponding primitive type.
  • Happens implicitly when a wrapper object is used where a primitive value is expected.

  • Integer wrapperInt = 20;
    int primitiveInt = wrapperInt; // Unboxing: Integer to int
    System.out.println(primitiveInt); // Output: 20
    
    // Example in arithmetic operations
    Integer a = 5;
    int b = a + 3; // 'a' is unboxed to int for the addition
    System.out.println(b); // Output: 8
    

• Benefits: Simplifies code by reducing the need for explicit type conversions, making it cleaner and less verbose. However, it can sometimes lead to NullPointerException if a null wrapper object is unboxed.

The volatile keyword in Java ensures that a variable's value is always read from and written to main memory, not from CPU caches.

• Visibility: Guarantees that changes made to a volatile variable by one thread are immediately visible to all other threads.
  • Without volatile, a thread might keep a variable's value in its local cache, leading to inconsistent views across threads.
• Ordering (Happens-Before Guarantee):
  • A write to a volatile variable happens-before any subsequent read of that volatile variable.
  • It also prevents instruction reordering by the compiler and CPU around volatile accesses, which could otherwise lead to unexpected behavior in concurrent programs.
• When to Use: volatile is typically used in the following scenarios:
  • Flags/Status Variables: When a flag variable (e.g., boolean shutdownRequested) is updated by one thread and checked by another to signal a state change.
  • Single-Writer, Multiple-Reader Scenarios: For variables that are written by only one thread but read by multiple threads, where full synchronization (like synchronized blocks) would be overkill or too expensive.
  • It does not provide atomicity for operations that involve reading, modifying, and writing (e.g., count++). For atomic operations, java.util.concurrent.atomic classes or synchronized are needed.

  • class Worker {
        private volatile boolean running = true;
        public void stop() {
            running = false; // Change immediately visible to other threads
        }
        public void run() {
            while (running) {
                // Perform tasks
            }
            System.out.println("Worker stopped.");
        }
    }
    

The synchronized keyword in Java is used to achieve thread safety by controlling access to shared resources in a multi-threaded environment.

• Purpose: Prevents multiple threads from executing a specific block of code or method concurrently, thus avoiding data corruption and race conditions.
• Mechanism (Intrinsic Lock/Monitor):
  • Every object in Java has an associated intrinsic lock (also known as a monitor).
  • When a thread enters a synchronized block or method, it acquires the lock for the specified object.
  • No other thread can acquire the same lock until the first thread releases it.
  • The lock is automatically released when the thread exits the synchronized block/method (either normally or due to an exception).
• Usage: Can be applied to:
  • Methods: Synchronizes the entire method. The lock is acquired on the instance for non-static methods, and on the class object for static methods.

    public synchronized void incrementCount() {
        count++; // Only one thread can execute this at a time for this object
    }
    public static synchronized void incrementStaticCount() {
        staticCount++; // Only one thread can execute this at a time for this class
    }
    

  • Blocks: Synchronizes a specific block of code using an object as the monitor. This provides finer-grained control.

    private final Object lock = new Object(); // A dedicated lock object
    public void updateResource() {
        synchronized (lock) { // Acquires lock on 'lock' object
            // Critical section: access shared resource
        }
    }
    

• Guarantees: synchronized provides both mutual exclusion (only one thread can enter) and visibility (changes made within a synchronized block are visible to other threads when they subsequently acquire the same lock).

try-with-resources is a try statement that declares one or more resources, introduced in Java 7.

• Purpose: It ensures that each resource declared in the try statement is closed automatically at the end of the try block, regardless of whether the try block completes normally or abruptly due to an exception.
• Resource Definition: A resource is any object that implements the java.lang.AutoCloseable interface (which includes java.io.Closeable).
• Benefits:
  • Automatic Resource Management: Eliminates the need for explicit finally blocks to close resources, making code cleaner and less error-prone.
  • Reduces Boilerplate: Significantly reduces the amount of boilerplate code associated with resource handling.
  • Improved Reliability: Ensures resources are always closed, even in the presence of exceptions, preventing resource leaks.
• Syntax:

  try (ResourceType resource1 = new ResourceType();
       ResourceType resource2 = new ResourceType()) {
      // Use resource1 and resource2
      // They will be closed automatically here
  } catch (IOException e) {
      // Handle exceptions
  }
  

• Example: Reading from a file.

  import java.io.BufferedReader;
  import java.io.FileReader;
  import java.io.IOException;
  
  public class FileProcessor {
      public void readFile(String filePath) {
          try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
              String line;
              while ((line = reader.readLine()) != null) {
                  System.out.println(line);
              }
          } catch (IOException e) {
              System.err.println("Error reading file: " + e.getMessage());
          }
      }
  }
  

Lambda expressions (introduced in Java 8) provide a concise way to represent an instance of a functional interface (an interface with exactly one abstract method).

• Purpose: Primarily used to implement functional interfaces directly in place, enabling functional programming paradigms like passing behavior as arguments.
• Syntax: (parameters) -> expression or (parameters) -> { statements; }
  • parameters: List of parameters (can be empty, single without parentheses, or multiple with parentheses).
  • ->: The arrow operator, separating parameters from the body.
  • expression or statements: The body of the lambda.
• Benefits:
  • Conciseness: Reduces boilerplate code compared to anonymous inner classes.
  • Readability: Makes code more readable for simple callbacks and behaviors.
  • Functional Programming: Enables use with the Stream API for powerful data processing.
• Example 1: Implementing a Runnable interface:

  // Before Java 8 (Anonymous Inner Class)
  new Thread(new Runnable() {
      @Override
      public void run() {
          System.out.println("Hello from anonymous inner class!");
      }
  }).start();
  
  // With Lambda Expression
  new Thread(() -> System.out.println("Hello from lambda!")).start();
  

• Example 2: Custom functional interface:

  @FunctionalInterface
  interface MyConverter<F, T> {
      T convert(F from);
  }
  
  MyConverter<String, Integer> stringToInt = (s) -> Integer.valueOf(s);
  Integer num = stringToInt.convert("123"); // num is 123
  
  MyConverter<Integer, String> intToString = (i) -> "Number: " + i;
  String text = intToString.convert(456); // text is "Number: 456"
  

The Stream API (introduced in Java 8) provides a powerful and flexible way to process collections of objects in a functional style.

• Purpose: Enables performing sequential or parallel operations on data sequences (like collections, arrays, I/O channels) without modifying the original data source.
• Key Characteristics:
  • Functional: Operations are expressed as lambda expressions.
  • Declarative: Focuses on what to do, rather than how to do it.
  • Pipelining: Operations can be chained together to form a pipeline.
  • Lazy Evaluation: Intermediate operations are not executed until a terminal operation is invoked.
  • Internal Iteration: The Stream API handles the iteration internally, abstracting it away from the developer.
• Stream Operations:
  • Intermediate Operations: Transform a stream into another stream (e.g., filter(), map(), sorted()). They are lazy.
  • Terminal Operations: Produce a result or a side-effect, closing the stream (e.g., forEach(), collect(), reduce(), count()). They trigger the execution of intermediate operations.
• Simple Example: Filtering and transforming a list of numbers.

  import java.util.Arrays;
  import java.util.List;
  import java.util.stream.Collectors;
  
  public class StreamExample {
      public static void main(String[] args) {
          List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  
          // Filter even numbers, double them, and collect into a new list
          List<Integer> processedNumbers = numbers.stream()
                                                .filter(n -> n % 2 == 0) // Intermediate: keep only even numbers
                                                .map(n -> n * 2)      // Intermediate: double each number
                                                .collect(Collectors.toList()); // Terminal: collect results into a List
  
          System.out.println(processedNumbers); // Output: [4, 8, 12, 16, 20]
      }
  }
  

Reflection is a Java API that allows an executing Java program to examine or modify its own structure, components, and behavior at runtime.

• Purpose: Enables programs to inspect classes, interfaces, fields, and methods at runtime without knowing their names at compile time.
• Key Capabilities:
  • Introspection: Discover information about a class (e.g., its name, modifiers, superclass, interfaces implemented, fields, methods, constructors).
  • Instantiation: Create new instances of classes.
  • Method Invocation: Invoke methods of an object.
  • Field Access: Get and set values of fields (even private ones).
  • Dynamic Loading: Load classes dynamically.
• Core Classes: Key classes in java.lang.reflect:
  • Class: Represents classes and interfaces.
  • Constructor: Provides information about, and access to, a single constructor for a class.
  • Method: Provides information about, and access to, a single method on a class or interface.
  • Field: Provides information about, and dynamic access to, a single field of a class or an interface.
• Usage Scenarios:
  • IDEs/Debuggers: To inspect objects and classes.
  • Frameworks (e.g., Spring, Hibernate, JUnit): For dependency injection, ORM mapping, annotation processing, dynamic proxy generation.
  • Serialization/Deserialization Libraries: To read/write object states.
  • Testing Tools: To access private members for unit testing.
• Example: Inspecting a class and invoking a method

  import java.lang.reflect.Method;
  
  class MyReflectClass {
      private String name = "Default";
      public void sayHello() {
          System.out.println("Hello, " + name);
      }
      private void secretMethod(String message) {
          System.out.println("Secret: " + message);
      }
  }
  
  public class ReflectionDemo {
      public static void main(String[] args) throws Exception {
          // Get Class object for MyReflectClass
          Class<?> cls = MyReflectClass.class;
  
          // Create an instance
          MyReflectClass obj = (MyReflectClass) cls.getDeclaredConstructor().newInstance();
  
          // Get and invoke a public method
          Method helloMethod = cls.getMethod("sayHello");
          helloMethod.invoke(obj); // Output: Hello, Default
  
          // Get and invoke a private method (requires setAccessible(true))
          Method secretMethod = cls.getDeclaredMethod("secretMethod", String.class);
          secretMethod.setAccessible(true); // Override access checks
          secretMethod.invoke(obj, "Top Secret!"); // Output: Secret: Top Secret!
      }
  }
  

• Drawbacks: Can lead to reduced performance, security risks (bypassing access modifiers), and increased complexity, so it should be used judiciously.

Annotations in Java are a form of metadata that can be added to source code elements (classes, methods, fields, parameters, etc.) to provide information to the compiler, runtime environment, or other tools.

• Purpose: They don't directly affect the program's execution but provide supplemental information.
• Syntax: Begin with @ symbol, followed by the annotation name.
• Types of Annotations:
  • Built-in Annotations: Provided by Java itself.
  • Custom Annotations: Defined by developers for specific purposes.
  • Meta-Annotations: Annotations that annotate other annotations (e.g., @Retention, @Target).
• Information Source: Annotations are processed at different stages:
  • Compile-time: By the compiler for error checking or warnings (e.g., @Override).
  • Deployment-time: By build tools or deployment frameworks.
  • Runtime: By the JVM or applications using Reflection API (e.g., @Deprecated or custom annotations for configuration).
• Example of a Built-in Annotation: @Override
  • Purpose: Indicates that a method in a subclass is intended to override a method in its superclass or implement a method from an interface.
  • Compiler Benefit: If the annotated method does not correctly override a superclass method (e.g., due to a typo in the method signature), the compiler will generate a compile-time error, preventing subtle bugs.

  • class Animal {
        void speak() { System.out.println("Animal speaks"); }
    }
    
    class Dog extends Animal {
        @Override // Ensures this method correctly overrides speak() from Animal
        void speak() { System.out.println("Woof!"); }
    
        // @Override
        // void speek() { /* Compile-time error due to typo */ }
    }
    

• Other common built-in annotations: @Deprecated, @SuppressWarnings, @FunctionalInterface.

In Java's Object-Oriented Programming (OOP) paradigm, classes and objects are fundamental concepts:

• Class: A blueprint or a template for creating objects. It defines the common structure (attributes/fields) and behavior (methods) that all objects of that type will have. It's a logical entity and does not consume any memory at runtime.

  class Car {
      String model; // attribute
      int year;     // attribute
  
      void start() { // method
          System.out.println(model + " started.");
      }
  }
  

• Object: An instance of a class. It's a real-world entity that has a state (values of its attributes) and behavior. Objects are created from classes and consume memory.

  Car myCar = new Car(); // 'myCar' is an object of the Car class
  myCar.model = "Toyota";
  myCar.year = 2020;
  myCar.start();
  

Constructors are special methods used to initialize objects when they are created. They ensure that an object is in a valid state upon instantiation.

• A constructor's name must be the same as its class name.
• It has no return type, not even void.
• If no constructor is explicitly defined, Java provides a default constructor (no arguments, empty body).
• Constructors can be overloaded, meaning a class can have multiple constructors with different parameter lists.

public class Dog {
    String name;
    int age;

    // Default constructor (no-arg constructor)
    public Dog() {
        this.name = "Unnamed";
        this.age = 0;
    }

    // Parameterized constructor
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {
        Dog dog1 = new Dog();              // Uses no-arg constructor
        Dog dog2 = new Dog("Buddy", 5); // Uses parameterized constructor
        System.out.println(dog2.name); // Output: Buddy
    }
}

The this keyword in Java is a reference variable that refers to the current object.

• Referring to instance variables: It's commonly used to distinguish between instance variables and local variables (parameters) that have the same name.

  class Person {
      String name;
      Person(String name) {
          this.name = name; // 'this.name' refers to the instance variable
      }
  }
  

• Invoking current class constructor: this() can be used to call another constructor within the same class (constructor chaining).

  class Box {
      int width, height;
      Box() {
          this(10, 20); // Calls the parameterized constructor
      }
      Box(int width, int height) {
          this.width = width;
          this.height = height;
      }
  }
  

• Returning the current class instance: It can be returned from a method to allow method chaining.

Java categorizes exceptions into checked and unchecked exceptions, primarily differing in how the compiler handles them.

• Checked Exceptions: These are exceptions that are checked at compile time. The compiler forces you to either handle them (with try-catch blocks) or declare them (with a throws clause) in the method signature. If you don't, the code won't compile. They typically represent situations that an application can reasonably recover from, like IOException, SQLException, FileNotFoundException.

  // Example of a checked exception (FileNotFoundException)
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  
  public class FileReader {
      public void readFile(String fileName) throws FileNotFoundException { // Declared
          FileInputStream fis = new FileInputStream(fileName);
          // ... read file ...
      }
  }
  

• Unchecked Exceptions: These are exceptions that are not checked at compile time. The compiler doesn't force you to handle or declare them. They are typically subclasses of RuntimeException (e.g., NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException). They often indicate programming errors that should ideally be fixed in the code rather than caught and recovered from.

  // Example of an unchecked exception (ArithmeticException)
  public class Calculator {
      public int divide(int a, int b) {
          // No compile-time error even if 'b' can be 0
          return a / b; 
      }
  }
  

An enum (enumeration) in Java is a special data type that represents a fixed set of named constants. It's used when you need a collection of predefined values, making your code more readable and type-safe.

• enum constants are implicitly public static final.
• enums can have constructors, methods, and instance variables, just like regular classes.
• They are particularly useful for representing categories, states, or fixed options.

public enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

public class EnumExample {
    public static void main(String[] args) {
        Day today = Day.WEDNESDAY;

        if (today == Day.SATURDAY || today == Day.SUNDAY) {
            System.out.println("It's the weekend!");
        } else {
            System.out.println("It's a weekday."); // Output: It's a weekday.
        }

        // Enum can also have methods and fields
        // public enum Level { LOW, MEDIUM, HIGH; ... }
    }
}

Comparable and Comparator are two interfaces used to define custom sorting logic for objects in Java.

• Comparable: This interface defines the natural ordering for objects of a class. A class implements Comparable if its instances can be ordered inherently. It has a single method:
  • int compareTo(T o): Compares this object with the specified object o. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

  class Person implements Comparable<Person> {
      String name;
      public Person(String name) { this.name = name; }
      @Override
      public int compareTo(Person other) {
          return this.name.compareTo(other.name); // Sort by name naturally
      }
  }
  

• Comparator: This interface defines an external or custom ordering. It's used when you want to sort objects based on different criteria or when you cannot modify the class itself to implement Comparable. It has a single method:
  • int compare(T o1, T o2): Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

  import java.util.Comparator;
  
  class PersonAgeComparator implements Comparator<Person> {
      @Override
      public int compare(Person p1, Person p2) {
          return Integer.compare(p1.age, p2.age); // Sort by age
      }
  }
  // Usage: Collections.sort(list, new PersonAgeComparator());
  

The Optional class, introduced in Java 8, is a container object that may or may not contain a non-null value. It's primarily used to represent the presence or absence of a value, providing a way to handle null values gracefully and avoid NullPointerExceptions.

• Purpose: To replace the traditional null checks with a more explicit and functional way of dealing with potentially absent values, thereby improving code readability and robustness.
• Benefits: Reduces boilerplate null-check code, clearly indicates that a method might return no result, and promotes a more functional programming style.

import java.util.Optional;

public class OptionalExample {
    public static Optional<String> getNameById(int id) {
        if (id == 1) {
            return Optional.of("Alice"); // Value is present
        } else {
            return Optional.empty();     // Value is absent
        }
    }

    public static void main(String[] args) {
        Optional<String> name = getNameById(1);
        name.ifPresent(n -> System.out.println("Found name: " + n)); // Output: Found name: Alice

        Optional<String> absentName = getNameById(2);
        String defaultName = absentName.orElse("Unknown"); // Provides a default value
        System.out.println("Name for ID 2: " + defaultName); // Output: Name for ID 2: Unknown
    }
}

A Functional Interface in Java is an interface that contains exactly one abstract method. They are a core component for enabling Lambda Expressions in Java 8 and later, allowing them to be used as types for lambda expressions.

• They can have any number of default or static methods, but only one abstract method.
• The @FunctionalInterface annotation is optional but recommended. It helps the compiler enforce the "single abstract method" rule.
• Common examples include Runnable, Callable, ActionListener, Comparator, and interfaces from the java.util.function package like Predicate, Consumer, Function, Supplier.

@FunctionalInterface
interface MyConverter {
    String convert(int i); // Single abstract method

    // Can have default methods
    default void printHello() {
        System.out.println("Hello");
    }
}

public class FunctionalInterfaceExample {
    public static void main(String[] args) {
        // Using a lambda expression to implement the functional interface
        MyConverter converter = (num) -> "Converted: " + String.valueOf(num);
        System.out.println(converter.convert(123)); // Output: Converted: 123
        converter.printHello(); // Output: Hello
    }
}

ThreadLocal provides a way to store data that will be accessible only by a specific thread. Each thread that accesses a ThreadLocal variable gets its own independent copy of the variable.

• Purpose: To ensure thread isolation for mutable objects. If multiple threads were to share a single instance of an object, it could lead to concurrency issues. ThreadLocal avoids this by giving each thread its own private copy.
• Use Cases: Managing user session information, database connection pooling (where each thread needs its own connection), or storing context-specific data in a web application.
• Memory Leaks: It's important to call remove() on ThreadLocal variables when they are no longer needed, especially in thread pools, to prevent potential memory leaks.

public class ThreadLocalExample {
    // Each thread will have its own instance of SimpleDateFormat
    public static ThreadLocal<String> threadSafeData = new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        Runnable task1 = () -> {
            threadSafeData.set(Thread.currentThread().getName() + "-Data1");
            System.out.println(Thread.currentThread().getName() + ": " + threadSafeData.get());
            threadSafeData.remove(); // Important to prevent memory leaks
        };

        Runnable task2 = () -> {
            threadSafeData.set(Thread.currentThread().getName() + "-Data2");
            System.out.println(Thread.currentThread().getName() + ": " + threadSafeData.get());
            threadSafeData.remove();
        };

        new Thread(task1, "Thread-A").start();
        new Thread(task2, "Thread-B").start();
    }
}
// Possible Output:
// Thread-A: Thread-A-Data1
// Thread-B: Thread-B-Data2

An immutable class is a class whose objects cannot be modified after they are created. Once an object of an immutable class is instantiated, its state remains constant throughout its lifetime. Examples include String, Integer, and Boolean.

To create an immutable class, follow these steps:

• Declare the class as final: This prevents other classes from extending it and overriding its methods, which could potentially alter its immutability.
• Declare all fields as private and final: private restricts direct access, and final ensures that fields are initialized only once.
• Do not provide setter methods: Since the object's state cannot change, there should be no methods to modify its fields.
• Initialize all fields via the constructor: All fields must be set during object creation.
• Perform deep copies for mutable object fields: If the class holds references to mutable objects (e.g., Date, ArrayList), you must create new copies of these objects in the constructor and getter methods. This prevents external modification of the internal state.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

final class ImmutableStudent {
    private final int id;
    private final String name;
    private final List<String> courses; // Mutable field

    public ImmutableStudent(int id, String name, List<String> courses) {
        this.id = id;
        this.name = name;
        // Deep copy for mutable list
        this.courses = new ArrayList<>(courses);
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public List<String> getCourses() {
        // Return an unmodifiable view to prevent external modification
        return Collections.unmodifiableList(courses);
    }
}

The Java Memory Model defines how threads interact through memory and what behavior is guaranteed when multiple threads read/write shared variables.

• Specifies rules for visibility (when a write by one thread becomes visible to another) and ordering (how instructions may be reordered).
• Without proper synchronization, the compiler/JIT/CPU are free to reorder or cache reads, causing stale or inconsistent values across threads.
• Keywords like synchronized, volatile, and classes in java.util.concurrent establish happens-before relationships that guarantee visibility and ordering.

volatile boolean running = true; // guarantees visibility across threads

Both implement the Map interface, but differ in thread-safety and performance.

• HashMap is not thread-safe — concurrent modification from multiple threads can corrupt internal state or throw ConcurrentModificationException.
• ConcurrentHashMap is thread-safe and designed for high concurrency, using internal lock striping (segments/bins) instead of locking the entire map.
• ConcurrentHashMap never blocks reads and allows a configurable number of concurrent writes, making it much faster than wrapping a HashMap with Collections.synchronizedMap().

Map<String, Integer> map = new ConcurrentHashMap<>();
map.put("count", 1);

A memory leak occurs when objects that are no longer needed are still reachable, so the garbage collector can't reclaim them.

• Common causes: unclosed resources, static collections that keep growing, listeners/callbacks never unregistered, and inner classes holding implicit references to their outer class.
• Caching without eviction is a classic culprit — a Map used as a cache that never removes old entries.
• Fix: use WeakReference/SoftReference for caches, always close resources (or use try-with-resources), and unregister listeners when done.

The JVM offers several GC algorithms, each with different trade-offs between throughput and pause time.

• Serial GC: single-threaded, best for small applications with limited memory.
• Parallel GC: multi-threaded, focuses on maximizing throughput.
• CMS (Concurrent Mark Sweep): minimizes pause times by doing most work concurrently with the application (deprecated since Java 9).
• G1 (Garbage First): default since Java 9 — splits the heap into regions and balances throughput with predictable pause times.
• ZGC / Shenandoah: designed for very large heaps with sub-millisecond pause times.

transient marks a field to be excluded from serialization.

• When an object is serialized (via Serializable), transient fields are skipped and get their default value (null, 0, false) upon deserialization.
• Commonly used for fields that are sensitive (passwords), derived/cacheable, or not serializable themselves (e.g., a Thread reference).

class User implements Serializable {
    String username;
    transient String password; // not saved when serialized
}

Serialization converts an object's state into a byte stream; deserialization reconstructs the object from that stream.

• A class must implement the Serializable marker interface to be eligible.
• Used for persisting objects to disk, sending them over a network, or caching.
• serialVersionUID should be explicitly declared to control version compatibility between serialized and current class versions.

ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.ser"));
out.writeObject(myObject);

Externalizable gives the developer full manual control over serialization, unlike the default mechanism used by Serializable.

• Requires implementing writeExternal() and readExternal() to explicitly define what gets written/read.
• Offers better performance and flexibility for complex objects, since the default reflection-based serialization is skipped.
• Requires a public no-arg constructor, since the JVM must be able to instantiate the object before readExternal() populates it.

Records (introduced in Java 14 as preview, standard in Java 16) are a concise way to declare immutable data-carrier classes.

• The compiler automatically generates a constructor, equals(), hashCode(), toString(), and accessor methods.
• Fields are private final by default — records are inherently immutable.
• Ideal for simple DTOs where you'd otherwise write a lot of boilerplate.

record Point(int x, int y) {}

Point p = new Point(3, 4);
System.out.println(p.x()); // 3

var enables local variable type inference — the compiler determines the type from the assigned value.

• Only usable for local variables with an initializer, not for fields, method parameters, or return types.
• Improves readability for verbose generic types without sacrificing static typing (the type is still fixed at compile time).

var list = new ArrayList<String>(); // inferred as ArrayList<String>

Sealed classes/interfaces restrict which classes are allowed to extend or implement them.

• Declared with the sealed modifier and a permits clause listing allowed subclasses.
• Gives more control over class hierarchies than final (which allows no subclassing at all) while still limiting extension.
• Pairs well with pattern matching in switch since the compiler knows all possible subtypes.

sealed interface Shape permits Circle, Square {}
final class Circle implements Shape {}
final class Square implements Shape {}

A deadlock occurs when two or more threads are blocked forever, each waiting for a lock held by the other.

• Classic scenario: Thread A locks Resource 1 and waits for Resource 2, while Thread B locks Resource 2 and waits for Resource 1.
• Avoidance strategies: always acquire locks in a consistent global order, use lock timeouts (tryLock()), or minimize the scope/number of locks held simultaneously.

if (lock1.tryLock() && lock2.tryLock()) {
    // proceed safely
}

Both represent a task to run on another thread, but differ in return value and error handling.

• Runnable: run() returns void and cannot throw a checked exception.
• Callable<V>: call() returns a value of type V and can throw a checked exception.
• Callable is typically submitted to an ExecutorService, returning a Future<V> to retrieve the result later.

Callable<Integer> task = () -> 42;
Future<Integer> result = executor.submit(task);

ExecutorService is a higher-level replacement for manually creating and managing Thread objects.

• Manages a pool of worker threads and a task queue, decoupling task submission from execution.
• Common factory methods: Executors.newFixedThreadPool(), newCachedThreadPool(), newSingleThreadExecutor().
• Always call shutdown() (or shutdownNow()) when done to release threads.

ExecutorService executor = Executors.newFixedThreadPool(4);
executor.submit(() -> System.out.println("Task running"));
executor.shutdown();

CompletableFuture (Java 8+) represents a future result of an asynchronous computation, with a rich API for chaining and combining tasks.

• Unlike a plain Future, it supports non-blocking callbacks via methods like thenApply(), thenAccept(), and thenCombine().
• Allows composing multiple async operations into a pipeline without manually blocking threads with get().

CompletableFuture.supplyAsync(() -> fetchData())
    .thenApply(data -> process(data))
    .thenAccept(System.out::println);

This describes how an iterator behaves when the underlying collection is modified during iteration.

• Fail-fast (e.g., ArrayList, HashMap): throws ConcurrentModificationException immediately if the collection is structurally modified while iterating.
• Fail-safe (e.g., CopyOnWriteArrayList, ConcurrentHashMap): iterates over a snapshot or tolerates concurrent changes, never throwing that exception, though it may not reflect the very latest updates.

java.util.Objects provides static null-safe helper methods for common object operations.

• Objects.equals(a, b) — safely compares two references, handling null without throwing NullPointerException.
• Objects.hash(a, b, c) — generates a combined hash code for multiple fields, useful inside hashCode() overrides.
• Objects.requireNonNull(obj) — throws NullPointerException with a clear message if obj is null, useful for argument validation.

public int hashCode() {
    return Objects.hash(name, age);
}

The Builder pattern constructs complex objects step by step, avoiding constructors with many parameters (telescoping constructors).

• Especially useful for objects with many optional fields, improving readability over long constructor argument lists.
• Each builder method typically returns this, enabling a fluent, chained API.

Pizza pizza = new Pizza.Builder()
    .size("Large")
    .cheese(true)
    .pepperoni(true)
    .build();

A Singleton ensures only one instance of a class exists. Making it thread-safe requires care in a multithreaded environment.

• Eager initialization: instance created at class-load time — simple and thread-safe, but instantiated even if never used.
• Double-checked locking with volatile: lazy and thread-safe, minimizes synchronization overhead after the first initialization.
• Enum singleton: the simplest thread-safe approach, and naturally protects against reflection and serialization attacks.

enum Singleton {
    INSTANCE;
    void doWork() { /* ... */ }
}

Both create a new object, but differ in how nested/referenced objects are handled.

• Shallow copy: copies the top-level object, but nested object references still point to the same underlying objects as the original (changes to nested objects affect both copies).
• Deep copy: recursively copies all nested objects too, so the copy is fully independent of the original.
• Object.clone() performs a shallow copy by default; a deep copy usually requires manually cloning each mutable field or using serialization-based copying.

Both coordinate threads waiting on a condition, but the Lock/Condition API (java.util.concurrent.locks) is more flexible.

• wait()/notify() must be called from within a synchronized block on the object's intrinsic lock, and notify() wakes an arbitrary waiting thread.
• Condition (created from a Lock) allows multiple wait-sets per lock, so you can selectively signal specific groups of waiting threads via signal()/signalAll().

Lock lock = new ReentrantLock();
Condition notEmpty = lock.newCondition();