Object Oriented Programming (PCC-CS503) Complete Question Bank

OOP is a paradigm based on 'objects' containing data and methods. Unlike Procedural Programming, which focuses on functions and top-down logic, OOP emphasizes data security (encapsulation) and reusability.

A Class is a blueprint or template that defines variables and methods. An Object is a runtime instance of a class containing actual values.

Encapsulation is wrapping data (variables) and code (methods) into a single unit. Data Hiding restricts direct access to internal data, usually achieved via private access modifiers.

Abstraction hides complex implementation details and shows only the essential features. In Java, it is implemented using abstract classes and interfaces.

Inheritance is a mechanism where a new class inherits properties and behaviors of an existing class. Its primary benefit is code reusability.

Polymorphism allows entities to take multiple forms. Compile-time (method overloading) is resolved during compilation, while Run-time (method overriding) is resolved dynamically at execution.

A Constructor is a special method used to initialize objects. Characteristics: it has the same name as the class, has no return type, and is called automatically during object creation.

Constructor overloading is defining multiple constructors in a class with different parameter lists (different number or types of arguments) to initialize objects in various ways.

The 'this' keyword is a reference variable in Java that refers to the current object. It is used to resolve naming conflicts between instance variables and parameters.

The 'super' keyword refers to the immediate parent class object. It is used to call parent class constructors, methods, and access hidden parent fields.

Overloading occurs in the same class with same method name but different parameters (compile-time). Overriding occurs in a subclass with the exact same signature as the parent method (run-time).

Java doesn't support multiple inheritance with classes to avoid the Diamond Problem (ambiguity when multiple parent classes have a method with the same signature).

A class can implement multiple interfaces simultaneously because interfaces only contain abstract methods (prior to Java 8), so there is no ambiguity in method implementation.

An Abstract Class can have both abstract and concrete methods with state, while an Interface historically has only abstract methods and static final constants, and a class can implement multiple interfaces.

• public: Accessible everywhere.
• private: Accessible only within the same class.
• protected: Accessible within the package and subclasses.
• default: Accessible only within the same package.

A static variable belongs to the class rather than instances, shared among all objects. A static method can be called without creating an object and can only directly access static data.

• Variables: Creates a constant.
• Methods: Prevents overriding.
• Classes: Prevents inheritance.

Garbage Collection automatically frees memory by destroying unreachable objects. System.gc() requests a garbage collection run, and finalize() is a method called just before an object is destroyed for cleanup.

A Package is a namespace that organizes a set of related classes and interfaces. It is created using the package keyword at the top of the file and imported using the import keyword.

Exception Handling manages runtime errors to maintain normal flow. Checked exceptions are verified at compile-time (e.g., IOException), while Unchecked exceptions occur at runtime (e.g., NullPointerException).

• try: Wraps risky code.
• catch: Handles exceptions.
• finally: Executes crucial cleanup code.
• throw: Manually triggers an exception.
• throws: Declares exceptions a method might throw.

A user-defined exception is a custom exception class created by a developer (usually by extending the Exception or RuntimeException class) to handle application-specific errors.

Multithreading is the concurrent execution of multiple threads to maximize CPU utilization. A Thread is the smallest lightweight unit of processing or execution within a program.

Process-based involves heavyweight independent programs with separate memory spaces. Thread-based involves lightweight concurrent paths of execution that share the same memory space within one process.

A thread can be created either by extending the Thread class and overriding run(), or by implementing the Runnable interface and passing it to a Thread constructor.

Thread priorities dictate the order in which threads are scheduled. In Java, priorities range from 1 (MIN_PRIORITY) to 10 (MAX_PRIORITY), with 5 being the default (NORM_PRIORITY).

Thread Synchronization restricts multiple threads from accessing shared resources concurrently to prevent data inconsistency. The synchronized keyword locks the object or class during execution.

Inter-Thread Communication allows synchronized threads to communicate. wait() pauses a thread, while notify() and notifyAll() wake up one or all waiting threads on that monitor.

Deadlock is a situation where two or more threads are blocked forever, each waiting for a lock held by the other, bringing the program to a halt.

The String class represents a sequence of characters. Strings are immutable (unchangeable) for security, synchronization, caching, and to optimize the String Pool memory management.

String is immutable. StringBuilder is mutable and not thread-safe (faster). StringBuffer is mutable and thread-safe (synchronized, slower).

A Wrapper Class encapsulates a primitive type into an object. Autoboxing is automatic conversion of primitive to wrapper object; Unboxing is the reverse conversion.

The JCF is a unified architecture providing ready-to-use classes and interfaces (like List, Set, Map) for storing, manipulating, and searching groups of objects.

• List: Ordered collection that allows duplicates.
• Set: Unordered collection with no duplicates.
• Map: Collection of Key-Value pairs, keys must be unique.

ArrayList uses a dynamic array (better for searching/random access). LinkedList uses a doubly linked list (better for frequent insertions/deletions).

HashMap is a Map implementation that stores key-value pairs using a hash table. It uses a hashing algorithm on keys to compute indices for bucketing values.

Generics allow types (classes and interfaces) to be parameters when defining classes, interfaces, and methods. Their main advantage is compile-time type safety and avoiding explicit casting.

File I/O handles reading and writing to files. Byte Streams (e.g., FileInputStream) read/write 8-bit bytes (for binary data). Character Streams (e.g., FileReader) read/write 16-bit Unicode characters.

Serialization converts an object's state into a byte stream for saving or networking. Deserialization reconstructs the object from the byte stream.

The transient keyword marks a variable so that it is ignored during serialization; its value will not be saved or transmitted.

A Lambda Expression provides a concise syntax to write anonymous methods, typically used to implement the single abstract method of a functional interface.

A Functional Interface has exactly one abstract method. Examples include Runnable and Callable (or Predicate and Function from java.util.function).

The Stream API provides a functional and declarative approach to process collections of objects (filtering, mapping, reducing) allowing for easy parallel execution.

Design Patterns are proven solutions to common software design problems. Creational deals with object creation, Structural with object composition, and Behavioral with object communication.

The Singleton pattern ensures that a class has only one single instance throughout the application lifecycle and provides a global point of access to it.

The Factory Method is a creational pattern that defines an interface for creating objects, but lets subclasses decide which class to instantiate.

SOLID stands for Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—five principles for maintainable object-oriented design.

UML is a standard visual modeling language used in software engineering to document, specify, construct, and visualize the artifacts of a software system.

Association is a general relationship. Aggregation is a "has-a" relationship (weak ownership). Composition is a strict "part-of" relationship (strong ownership, part dies with whole).

A Class Diagram is a structural UML diagram that shows the system's static structure by detailing classes, their attributes, methods, and relationships.

A Virtual Function allows derived classes to override a method for runtime polymorphism. A Pure Virtual Function (assigned = 0) forces derived classes to implement it, making the base class abstract.

A Friend Function/Class in C++ is granted access to the private and protected members of the class in which it is declared as a friend.

Q1. Discuss the four fundamental pillars of Object-Oriented Programming (OOP) with real-world examples.

Object-Oriented Programming is a paradigm based on the concept of 'objects', which can contain data (attributes/fields) and code (methods). The four fundamental pillars that define OOP are:

• Encapsulation: This is the mechanism of wrapping data (variables) and code acting on the data (methods) together as a single unit (a class). In encapsulation, the variables of a class are hidden from other classes and can only be accessed through the methods of their current class. Therefore, it is also known as data hiding.
  Real-World Example: A medicinal capsule. The medicine (data/variables) is safely hidden inside the capsule cover (methods). Or a Bank Account where the balance is private and only updated via deposit() or withdraw() methods.
• Inheritance: It is a mechanism wherein a new class is derived from an existing class. The new class (subclass) inherits the attributes and methods of the existing class (superclass). This promotes code reusability and establishes an IS-A relationship.
  Real-World Example: A Vehicle class might have properties like wheels and methods like startEngine(). A Car class inherits from Vehicle, automatically gaining those features, but can add its own specific features like airConditioning().
• Polymorphism: Poly means "many" and morphism means "forms". Polymorphism allows us to perform a single action in different ways. In Java, this occurs via method overloading (compile-time) and method overriding (run-time).
  Real-World Example: A person can have different roles at the same time. A man can be a father, a husband, and an employee. Thus, the same person behaves differently depending on the situation (context). In code, a draw() method will behave differently for a Circle object vs a Square object.
• Abstraction: It is the property of hiding complex implementation details and showing only the essential features of the object. It helps to reduce programming complexity and effort.
  Real-World Example: Driving a car. You know that pressing the accelerator increases speed and pressing the brake stops it. You don't need to know the complex internal combustion engine mechanics to drive the car. In Java, this is achieved using abstract classes and interfaces.

Q2. Compare and contrast Procedural Programming with Object-Oriented Programming (OOP).

Programming paradigms dictate how we approach problem-solving in code. Procedural Oriented Programming (POP) and Object-Oriented Programming (OOP) are the two most prominent paradigms.

Conclusion: While POP is suitable for small, simple scripts where execution speed is critical, OOP is indispensable for building large, complex, maintainable, and scalable enterprise applications.

Q3. What is Constructor Chaining in Java? Explain with a relevant code snippet.

Constructor chaining is the process of calling one constructor from another constructor within the same class (or from a child class to a parent class) during the object creation process. This technique is primarily used to prevent code duplication and to ensure that multiple constructors share common initialization logic.

Types of Constructor Chaining:

• Within the same class: Achieved using the this() keyword. It must always be the first statement inside the constructor.
• From a child class to a parent class: Achieved using the super() keyword. It also must be the first statement. If not explicitly written, the Java compiler implicitly inserts a default super() call.

Code Example:

class Employee {
    String name;
    int id;
    String department;

    // Constructor 1 (Takes only name)
    public Employee(String name) {
        // Calls Constructor 2
        this(name, 0);
        System.out.println("Inside Constructor 1");
    }

    // Constructor 2 (Takes name and id)
    public Employee(String name, int id) {
        // Calls Constructor 3 (The main initialization constructor)
        this(name, id, "Unassigned");
        System.out.println("Inside Constructor 2");
    }

    // Constructor 3 (Takes all parameters)
    public Employee(String name, int id, String department) {
        // This constructor actually sets the values
        this.name = name;
        this.id = id;
        this.department = department;
        System.out.println("Inside Constructor 3");
    }
}

public class Main {
    public static void main(String[] args) {
        // When we call the single-parameter constructor, it triggers the chain.
        Employee emp = new Employee("Alice");
    }
}

Output of the above code:
Inside Constructor 3
Inside Constructor 2
Inside Constructor 1

As seen in the output, the this() call immediately pauses the execution of the current constructor and jumps to the target constructor, meaning the most parameterized constructor finishes executing first.

Q4. Explain Dynamic Method Dispatch (Runtime Polymorphism) in Java with an example.

Dynamic Method Dispatch is a mechanism by which a call to an overridden method is resolved at runtime, rather than at compile-time. This is how Java implements runtime polymorphism. When an overridden method is called through a superclass reference, Java determines which version of that method to execute based on the actual type of the object being referred to at the time the call occurs, not the type of the reference variable.

Key Rules:

• Upcasting is required: A superclass reference variable must point to a subclass object.
• The method must be overridden in the subclass.

Code Example:

class Animal {
    public void sound() {
        System.out.println("Animal makes a generic sound");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks: Woof Woof!");
    }
}

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows: Meow!");
    }
}

public class RuntimePolymorphismDemo {
    public static void main(String[] args) {
        // Superclass reference points to Animal object
        Animal myAnimal = new Animal();
        myAnimal.sound(); // Output: Animal makes a generic sound

        // Superclass reference points to Dog object (Upcasting)
        Animal myDog = new Dog(); 
        // At runtime, JVM checks the actual object type (Dog) 
        myDog.sound(); // Output: Dog barks: Woof Woof!

        // Superclass reference points to Cat object (Upcasting)
        Animal myCat = new Cat();
        myCat.sound(); // Output: Cat meows: Meow!
    }
}

Advantages: It allows Java to support overriding, which is central to OOP. It enables you to write robust, extensible code because you can write methods that accept a superclass parameter and they will automatically behave correctly for any subclass passed to them.

Q5. Differentiate between Abstract Class and Interface in Java.

Both abstract classes and interfaces are used to achieve abstraction in Java, but they have distinct differences in their design and usage.

Code Example:

// Interface
interface Drawable {
    void draw(); // implicitly public and abstract
}

// Abstract Class
abstract class Shape {
    String color;
    // Constructor in abstract class
    public Shape(String color) { this.color = color; }
    // Concrete method
    public void displayColor() { System.out.println("Color: " + color); }
    // Abstract method
    abstract double calculateArea();
}

// Concrete Class implementing Interface AND extending Abstract Class
class Circle extends Shape implements Drawable {
    double radius;
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    @Override
    public void draw() { System.out.println("Drawing a Circle."); }
    @Override
    double calculateArea() { return Math.PI * radius * radius; }
}

Q6. Explain Access Specifiers (Modifiers) in Java with examples.

Access specifiers determine the scope or visibility of classes, variables, methods, and constructors in Java. They are crucial for implementing Encapsulation (data hiding). Java provides four access specifiers:

• 1. private: The access level is restricted strictly within the class. It cannot be accessed from outside the class, not even by subclasses. It provides the highest level of security.
• 2. default (no keyword): If you don't explicitly specify an access modifier, it is considered 'default'. The access level is restricted within the same package. It cannot be accessed from outside the package.
• 3. protected: The access level is within the same package, and outside the package only through child classes (inheritance). If a class outside the package does not extend it, it cannot access protected members.
• 4. public: The access level is everywhere. It can be accessed from within the class, within the package, outside the package by subclasses, and outside the package by non-subclasses.

Code Summary:

package com.example.pack1;

public class Parent {
    private int privateVar = 1;      // Visible ONLY inside Parent
    int defaultVar = 2;              // Visible ONLY inside pack1
    protected int protectedVar = 3;  // Visible inside pack1 AND subclasses everywhere
    public int publicVar = 4;        // Visible everywhere

    public void show() {
        System.out.println(privateVar); // OK
    }
}

// Different package scenario:
package com.example.pack2;
import com.example.pack1.Parent;

class Child extends Parent {
    public void testAccess() {
        // System.out.println(privateVar);  // Error: private
        // System.out.println(defaultVar);  // Error: different package
        System.out.println(protectedVar);   // OK: accessed via inheritance
        System.out.println(publicVar);      // OK: public
    }
}

Q7. Describe the role of the 'static' keyword in Java.

The static keyword in Java is used primarily for memory management. It indicates that a particular member belongs to the class itself, rather than to instances (objects) of the class. It can be applied to variables, methods, blocks, and nested classes.

• 1. Static Variables: A static variable is shared among all objects of that class. Memory is allocated only once in the class area at the time of class loading. It is useful for representing common properties (e.g., company name for all employees).
• 2. Static Methods: A static method belongs to the class and can be invoked without creating an object of the class (using ClassName.methodName()). A crucial rule is that static methods can only directly access other static data and static methods; they cannot access non-static (instance) data directly or use this or super keywords.
• 3. Static Blocks: Used to initialize static variables. It is executed automatically exactly once when the class is loaded into memory, even before the main() method executes.

Code Example:

class Student {
    int rollNo; // Instance variable
    String name; // Instance variable
    static String college = "MIT"; // Static variable shared by all

    // Static Block
    static {
        System.out.println("Static Block Executed");
        // college = "Stanford"; // Can modify static variables here
    }

    public Student(int r, String n) {
        rollNo = r;
        name = n;
    }

    // Static Method
    public static void changeCollege(String newCollege) {
        college = newCollege;
        // name = "John"; // ERROR: Cannot make a static reference to non-static field
    }

    public void display() {
        System.out.println(rollNo + " " + name + " " + college);
    }
}

public class Main {
    public static void main(String[] args) {
        Student.changeCollege("Harvard"); // Calling static method without object
        Student s1 = new Student(101, "Alice");
        Student s2 = new Student(102, "Bob");
        
        s1.display(); // 101 Alice Harvard
        s2.display(); // 102 Bob Harvard
    }
}

Q8. What is the significance of the 'final' keyword in Java?

The final keyword in Java is a non-access modifier used to restrict the user. It can be applied in three different contexts: variables, methods, and classes. Once applied, it signifies that the entity is complete and cannot be altered.

• 1. Final Variable (Constant): When a variable is declared as final, its value cannot be changed once initialized. It effectively becomes a constant. A blank final variable (uninitialized at declaration) can only be initialized inside a constructor.
• 2. Final Method (Prevents Overriding): When a method is declared as final, it cannot be overridden by any subclasses. This is useful for locking down the implementation of a critical method to prevent unexpected behavior in child classes.
• 3. Final Class (Prevents Inheritance): When a class is declared as final, it cannot be extended (inherited) by any other class. For security and immutability reasons, many core Java classes like String, Integer, and Math are declared as final.

Code Example:

// 1. Final Class
final class Vehicle {
    public void drive() { System.out.println("Driving a vehicle"); }
}
// class Car extends Vehicle { } // ERROR: Cannot inherit from final Vehicle

class Parent {
    // 2. Final Method
    public final void show() {
        System.out.println("This is a final method");
    }
}

class Child extends Parent {
    // public void show() { } // ERROR: Cannot override final method
    
    public void testVariable() {
        // 3. Final Variable
        final int MAX_AGE = 100;
        // MAX_AGE = 101; // ERROR: Cannot assign a value to final variable
        System.out.println("Max age is: " + MAX_AGE);
    }
}

Q9. Describe Exception Handling in Java using try, catch, and finally blocks.

An exception is an unwanted or unexpected event occurring during the execution of a program (at runtime) that disrupts the normal flow of instructions. Java provides a robust mechanism to handle these exceptions so that the program can terminate gracefully or recover.

The Core Keywords:

• try: The try block encloses the code that might throw an exception. It must be followed by either a catch or a finally block.
• catch: The catch block is used to handle the exception thrown by the preceding try block. You can have multiple catch blocks to handle different types of exceptions specifically.
• finally: The finally block contains crucial code that must execute whether an exception occurs or not, and whether it is caught or not. It is primarily used for cleaning up resources (closing files, database connections, network sockets).

Code Example:

import java.util.Scanner;

public class ExceptionDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            System.out.print("Enter a number to divide 100 by: ");
            int divisor = scanner.nextInt();
            
            // Risky code that might throw an ArithmeticException
            int result = 100 / divisor; 
            System.out.println("Result: " + result);
            
        } catch (ArithmeticException e) {
            // Handled if divisor is 0
            System.out.println("Error: Cannot divide by zero!");
            
        } catch (Exception e) {
            // Generic catch-all for any other exception (e.g., InputMismatchException)
            System.out.println("An unexpected error occurred: " + e.getMessage());
            
        } finally {
            // This block ALWAYS executes
            System.out.println("Executing finally block: Closing resources.");
            scanner.close();
        }
        
        System.out.println("Program continues normally after try-catch-finally.");
    }
}

Q10. Differentiate between Checked and Unchecked Exceptions in Java.

In Java, the java.lang.Throwable class is the root class of all exceptions and errors. The exception hierarchy is divided into two primary categories: Checked and Unchecked exceptions.

Custom Exception:

Thread Life Cycle: New -> Runnable -> Running -> Blocked/Waiting -> Terminated.

Thread vs Runnable: Implementing Runnable is better as Java doesn't support multiple inheritance, so you can extend another class if needed.

Thread Synchronization: Prevents thread interference using synchronized keyword on methods or blocks.

Inter-Thread Communication: Threads communicate via wait(), notify(), and notifyAll() inside synchronized context.

Deadlock: Two or more threads are blocked forever, waiting for each other. Avoid by acquiring locks in a consistent order.

String Immutability: Strings cannot be changed once created for security, thread-safety, and performance (String Pool).

Autoboxing and Unboxing: Automatic conversion between primitive types and their corresponding wrapper classes.

ArrayList vs Vector: ArrayList is unsynchronized and fast. Vector is synchronized and slow.

HashMap Working: Uses hashing. Stores key-value pairs in buckets. Handles collisions using Linked Lists or Trees.

Java Generics and Wildcards: Generics provide compile-time type safety. Wildcards (?) allow flexibility in generic types.

Byte vs Character Streams: Byte streams (InputStream/OutputStream) read/write 1 byte at a time. Character streams (Reader/Writer) read/write 2 bytes (Unicode).

Serialization: Process of converting an object into a byte stream. Deserialization is the reverse.

Lambda Expressions: Anonymous functions in Java 8 that simplify code by treating functionality as a method argument.

Functional Interfaces: Interfaces with exactly one abstract method. Annotated with @FunctionalInterface.

Stream API:

Singleton Pattern: Ensures only one instance exists. Lazy initializes on first use; Eager initializes at class loading.

Factory Pattern: Creates objects without exposing the instantiation logic to the client.

SOLID Principles: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion.

UML Relationships: Association (uses-a), Aggregation (has-a, weak), Composition (part-of, strong).

Use Case Diagram: Visual representation of system interactions by actors and use cases.

Friend Functions: Functions in C++ that can access private/protected members of a class.

Operator Overloading: Giving special meaning to an existing operator in C++ for user-defined types.

Deep vs Shallow Copy: Shallow copy copies references. Deep copy creates new copies of the referenced objects.

Diamond Problem: Ambiguity in multiple inheritance. Solved in C++ using virtual inheritance.

Generic Stack:

Reflection API: Allows inspection and modification of classes, interfaces, fields, and methods at runtime.

Try-with-Resources: Automatically closes resources like files or sockets at the end of the statement.

Word Frequency:

MVC Architecture: Separates application into Model (data), View (UI), and Controller (logic).

Q1. Design and implement a Banking System in Java demonstrating Encapsulation, Inheritance, Polymorphism, Exception Handling, and File I/O.

Introduction
Object-Oriented Programming (OOP) provides a robust framework for building complex, real-world applications like a Banking System. By modeling the system using OOP principles, we ensure code reusability, security, and maintainability.

1. Core OOP Concepts Applied

• Encapsulation (Data Hiding): The account balance and account number must be kept secure. We declare them as private variables and provide controlled access via public getter and setter methods. This prevents unauthorized direct modification.
• Inheritance (Code Reusability): A generic Account class acts as the superclass. Specialized accounts like SavingsAccount and CurrentAccount inherit from it, promoting code reuse (e.g., both share the deposit logic).
• Polymorphism (Dynamic Dispatch): The withdraw() method behaves differently for a Savings Account (cannot withdraw below minimum balance) vs a Current Account (allows overdraft). We achieve this via Method Overriding.
• Exception Handling (Robustness): When a user tries to withdraw more than they have, instead of crashing, we throw a custom checked exception InsufficientFundsException.
• File I/O (Persistence): To maintain an audit trail, every transaction is logged to a text file using FileWriter and BufferedWriter.

2. System Architecture (UML Class Diagram)

3. Complete Java Implementation

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

// 1. Custom Exception (Exception Handling)
class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

// 2. Abstract Base Class (Abstraction & Encapsulation)
abstract class Account {
    private String accountNumber; // Encapsulated
    protected double balance;     // Accessible to child classes

    public Account(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    public String getAccountNumber() { return accountNumber; }
    public double getBalance() { return balance; }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            logTransaction("Deposited: $" + amount + " | New Balance: $" + balance);
        }
    }

    // Polymorphic method to be overridden
    public abstract void withdraw(double amount) throws InsufficientFundsException;

    // 3. File I/O for persistent logging
    protected void logTransaction(String message) {
        try (FileWriter fw = new FileWriter(accountNumber + "_log.txt", true);
             PrintWriter pw = new PrintWriter(fw)) {
            pw.println(message);
        } catch (IOException e) {
            System.err.println("Failed to log transaction for " + accountNumber);
        }
    }
}

// 4. Inheritance & Polymorphism (Savings Account)
class SavingsAccount extends Account {
    private double minimumBalance = 500.0;

    public SavingsAccount(String accNo, double initialBalance) {
        super(accNo, initialBalance);
    }

    @Override
    public void withdraw(double amount) throws InsufficientFundsException {
        if (balance - amount < minimumBalance) {
            throw new InsufficientFundsException("Transaction Failed: Minimum balance of $500 must be maintained.");
        }
        balance -= amount;
        logTransaction("Withdrew: $" + amount + " | New Balance: $" + balance);
    }
}

// 5. Inheritance & Polymorphism (Current Account)
class CurrentAccount extends Account {
    private double overdraftLimit = 1000.0;

    public CurrentAccount(String accNo, double initialBalance) {
        super(accNo, initialBalance);
    }

    @Override
    public void withdraw(double amount) throws InsufficientFundsException {
        if (balance - amount < -overdraftLimit) {
            throw new InsufficientFundsException("Transaction Failed: Overdraft limit of $" + overdraftLimit + " exceeded.");
        }
        balance -= amount;
        logTransaction("Withdrew: $" + amount + " | New Balance: $" + balance);
    }
}

// Execution Class
public class BankingSystem {
    public static void main(String[] args) {
        try {
            Account mySavings = new SavingsAccount("SAV-101", 2000);
            mySavings.deposit(500);
            mySavings.withdraw(300); // Success
            System.out.println("Savings Balance: $" + mySavings.getBalance());
            
            mySavings.withdraw(2000); // Throws Exception
        } catch (InsufficientFundsException e) {
            System.err.println(e.getMessage());
        }
    }
}

Conclusion

This implementation proves the power of OOP. If the bank decides to add a 'LoanAccount' tomorrow, we simply extend the Account class without modifying the existing, tested code (adhering to the Open/Closed Principle).

Q2. Critically analyze Dynamic Method Dispatch in Java. Show how run-time polymorphism enables runtime pluggability with code examples.

Introduction
Polymorphism in Java is divided into Compile-time (Method Overloading) and Run-time (Method Overriding). Dynamic Method Dispatch (DMD) is the core mechanism by which Java implements run-time polymorphism. It allows Java to determine which overridden method to call at runtime rather than at compile time.

1. The Mechanism of Dynamic Method Dispatch

In Java, a superclass reference variable can point to a subclass object. When an overridden method is called through this superclass reference, the Java Virtual Machine (JVM) looks at the actual object type created in memory at runtime, NOT the reference type, to decide which method implementation to execute.

• Compile Time: The compiler checks if the method exists in the superclass (the reference type). If it does, compilation succeeds.
• Run Time: The JVM invokes the method belonging to the actual object type assigned to the reference.

2. Why is DMD Important? (Runtime Pluggability)

DMD is the foundation of Runtime Pluggability (or the Strategy Pattern). It allows a system to swap out behaviors dynamically without recompiling the core logic. A common example is a Payment Gateway in an e-commerce application. The cart doesn't need to know how a payment is processed (Credit Card vs UPI), it just needs to know that the payment strategy can be processed.

3. Code Example: E-Commerce Payment Gateway

// 1. The Strategy Interface (Super type)
interface PaymentStrategy {
    void processPayment(double amount);
}

// 2. Concrete Implementation A (Sub type)
class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;
    public CreditCardPayment(String card) { this.cardNumber = card; }
    
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing $" + amount + " via Credit Card: " + cardNumber);
        // Complex credit card API logic here
    }
}

// 3. Concrete Implementation B (Sub type)
class UPIPayment implements PaymentStrategy {
    private String upiId;
    public UPIPayment(String upi) { this.upiId = upi; }
    
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing $" + amount + " via UPI: " + upiId);
        // Complex UPI API logic here
    }
}

// 4. The Core Application
class ShoppingCart {
    // Pluggable dependency - Notice we use the interface reference!
    private PaymentStrategy paymentMethod;

    // Injecting the strategy at runtime
    public void setPaymentMethod(PaymentStrategy strategy) {
        this.paymentMethod = strategy;
    }

    public void checkout(double totalAmount) {
        if (paymentMethod == null) throw new IllegalStateException("Select a payment method.");
        
        // Dynamic Method Dispatch happens here!
        // The compiler only knows paymentMethod is of type PaymentStrategy.
        // The JVM dynamically calls the CreditCard or UPI processPayment at runtime.
        paymentMethod.processPayment(totalAmount);
    }
}

// Execution
public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        
        // User selects UPI at runtime
        cart.setPaymentMethod(new UPIPayment("user@okhdfcbank"));
        cart.checkout(150.50); // Outputs: Processing $150.5 via UPI
        
        // User switches to Credit Card at runtime
        cart.setPaymentMethod(new CreditCardPayment("4111-2222-3333-4444"));
        cart.checkout(5000.00); // Outputs: Processing $5000.0 via Credit Card
    }
}

Conclusion

Without Dynamic Method Dispatch, the ShoppingCart class would require complex, hard-coded if-else or switch statements to handle different payment types. DMD allows the code to be incredibly clean, modular, and adhering strictly to the Open/Closed Principle (open for extension by adding new payment classes, closed for modification of the cart class).

Q3. Explain the Java Collections Framework (JCF). Differentiate between ArrayList, LinkedList, HashSet, and TreeSet with internal working details and time complexities.

Introduction
The Java Collections Framework (JCF) is a unified architecture representing and manipulating collections of objects (like a dynamic array, a set, or a queue). It provides ready-to-use, highly optimized, and standardized interfaces and classes, drastically reducing programming effort and increasing performance.

1. Architecture of JCF

The framework revolves around two main root interfaces:

• Collection Interface: The root of the collection hierarchy. Extended by List, Set, and Queue.
• Map Interface: Represents key-value pairs. Does not extend the Collection interface but is part of the JCF.

2. Detailed Comparison of Key Data Structures

Understanding the internal working of these classes is crucial for writing performant Java applications.

3. Internal Working Details

• ArrayList: It starts with an initial capacity (default 10). When it gets full, it creates a new array (usually 1.5x the size), copies old elements over, and discards the old array. This makes adding elements at the end O(1) amortized, but inserting in the middle is O(N) due to array shifting.
• LinkedList: Consists of 'Nodes'. Each node holds data, a pointer to the previous node, and a pointer to the next node. There is no contiguous memory allocation. Memory overhead is higher per element compared to ArrayList.
• HashSet: Under the hood, it uses a HashMap where the element you insert is the 'Key' and a dummy object is the 'Value'. It uses the hashCode() and equals() methods to resolve hash collisions (using buckets with linked lists or balanced trees).
• TreeSet: Backed by a TreeMap. It relies on the Comparable interface (or a provided Comparator) to organize the nodes in a Red-Black tree, ensuring operations remain O(log N) even in worst-case scenarios.

Conclusion

Choosing the right collection is the hallmark of a good Java developer. If you need fast access, use ArrayList. If you need fast sorting, use TreeSet. If you need lightning-fast unique storage, use HashSet. The JCF provides a perfectly tuned tool for every scenario.

Q4. Implement a Producer-Consumer problem in Java using Multithreading, Thread Synchronization, and wait()/notify() mechanisms.

Introduction
The Producer-Consumer problem is a classic synchronization problem in concurrent programming. It involves two threads, a Producer and a Consumer, sharing a common, fixed-size buffer. The Producer's job is to generate data and put it into the buffer. The Consumer's job is to consume the data from the buffer. The challenge is to ensure the Producer doesn't try to add data to a full buffer, and the Consumer doesn't try to remove data from an empty buffer.

1. The Java Implementation

We use Java's built-in monitor locks (synchronized blocks) along with the wait() and notify() methods inherited from the Object class to achieve Inter-Thread Communication.

import java.util.LinkedList;

// The Shared Buffer Class
class SharedBuffer {
    private LinkedList<Integer> list = new LinkedList<>();
    private int capacity = 2; // Bounded buffer size

    // Called by Producer thread
    public void produce() throws InterruptedException {
        int value = 0;
        while (true) {
            synchronized (this) {
                // Wait if buffer is full
                while (list.size() == capacity) {
                    System.out.println("Buffer is full. Producer is waiting...");
                    wait(); // Releases lock and waits
                }

                System.out.println("Producer produced: " + value);
                list.add(value++); // Add data to buffer

                // Notify the consumer that data is available
                notify();

                // Sleep to simulate time taken to produce
                Thread.sleep(1000);
            }
        }
    }

    // Called by Consumer thread
    public void consume() throws InterruptedException {
        while (true) {
            synchronized (this) {
                // Wait if buffer is empty
                while (list.size() == 0) {
                    System.out.println("Buffer is empty. Consumer is waiting...");
                    wait(); // Releases lock and waits
                }

                // Consume data
                int val = list.removeFirst();
                System.out.println("Consumer consumed: " + val);

                // Notify the producer that space is available
                notify();

                // Sleep to simulate time taken to consume
                Thread.sleep(1000);
            }
        }
    }
}

// Main Execution Class
public class ProducerConsumerDemo {
    public static void main(String[] args) throws InterruptedException {
        final SharedBuffer buffer = new SharedBuffer();

        // Create Producer Thread
        Thread producerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try { buffer.produce(); }
                catch (InterruptedException e) { e.printStackTrace(); }
            }
        });

        // Create Consumer Thread
        Thread consumerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try { buffer.consume(); }
                catch (InterruptedException e) { e.printStackTrace(); }
            }
        });

        // Start both threads
        producerThread.start();
        consumerThread.start();
    }
}

2. Concept Analysis

• synchronized(this): Ensures that only one thread can execute the block of code inside the shared buffer at any given time, preventing race conditions.
• while(...) { wait(); }: A while loop is crucial here, not an if statement. When a thread wakes up from wait(), it must re-check the condition (spurious wakeups or another thread grabbing the lock first).
• notify(): Wakes up a single thread that is waiting on the object's monitor (lock). In this two-thread scenario, notify() works perfectly. If there were multiple producers/consumers, notifyAll() would be necessary to prevent deadlocks.

Q5. Analyze Java Exception Handling architecture. Write a robust program handling multiple catch blocks, nested try-catch, and custom exceptions.

Introduction
Java's Exception Handling architecture is designed to manage runtime errors gracefully, ensuring the normal flow of the application is maintained. The root of the exception hierarchy is the Throwable class, which splits into Error (serious JVM problems, usually unrecoverable like OutOfMemoryError) and Exception (recoverable conditions).

1. Key Architectural Components

• Checked Exceptions: Verified at compile-time (e.g., IOException). The compiler forces you to handle them (try/catch or throws).
• Unchecked Exceptions: Subclasses of RuntimeException (e.g., NullPointerException). Not checked at compile-time; usually indicate programming logic errors.
• Keywords: try (encloses risky code), catch (handles specific exceptions), finally (guaranteed execution for cleanup), throw (explicitly throws an exception), throws (declares exceptions a method might throw).

2. Comprehensive Implementation Example

The following code demonstrates a robust architecture combining Custom Exceptions, Nested Try-Catch, Multiple Catch blocks, and the Finally block.

import java.util.Scanner;

// 1. Creating a Custom Checked Exception
class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

public class RobustExceptionHandling {
    
    // Method declaring it might throw a custom checked exception
    public static void validateVoterEligibility(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Applicant is under 18. Voting strictly prohibited.");
        }
        System.out.println("Age verified. Applicant is eligible to vote.");
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Outer Try-Catch
        try {
            System.out.print("Enter total registered voters (for calculation): ");
            String inputVoters = scanner.nextLine();
            
            // Multiple Catch scenario - parsing integer
            int totalVoters = Integer.parseInt(inputVoters);
            
            System.out.print("Enter polling booths available: ");
            int booths = scanner.nextInt();
            
            // Nested Try-Catch for specific logic isolation
            try {
                int votersPerBooth = totalVoters / booths;
                System.out.println("Voters per booth: " + votersPerBooth);
            } catch (ArithmeticException ae) {
                System.err.println("Inner Catch: Cannot divide by zero booths! " + ae.getMessage());
            }

            System.out.print("Enter voter age for registration: ");
            int age = scanner.nextInt();
            
            // Calling a method that throws a checked exception
            validateVoterEligibility(age);
            
        } 
        // Handling Multiple Exceptions (Ordering matters: Most specific to least specific)
        catch (NumberFormatException nfe) {
            System.err.println("Outer Catch: Invalid number format. Please enter valid integers.");
        } 
        catch (InvalidAgeException iae) {
            System.err.println("Outer Catch: Validation Error -> " + iae.getMessage());
        } 
        catch (Exception e) {
            // Generic fallback for any unforeseen exceptions
            System.err.println("Outer Catch: An unexpected error occurred -> " + e.toString());
        } 
        finally {
            // Cleanup block always executes
            System.out.println("Finally Block: Releasing scanner resources and closing connection.");
            scanner.close();
        }
        
        System.out.println("Program execution completed smoothly.");
    }
}

3. Best Practices Highlighted

• Custom Exceptions: Provide specific domain meaning (like InvalidAgeException) rather than generic exceptions.
• Catch Ordering: NumberFormatException and InvalidAgeException are caught before the generic Exception. If Exception e was first, compilation would fail (unreachable code).
• Resource Management: The finally block ensures the Scanner is closed regardless of whether the program crashes or succeeds.
• Nested Blocks: The division by zero logic is isolated. If an ArithmeticException occurs, the inner catch handles it, and the program continues to the next line (asking for voter age), demonstrating true recovery.

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...

Answer to be generated...