OOPs Concepts Interview Questions & Answers

class Car {
    String color;
    String model;
    void start() { /* ... */ }
}
// Creating objects
Car myCar = new Car();
myCar.color = "Red";
myCar.model = "Sedan";
Car yourCar = new Car();
yourCar.color = "Blue";

class Account {
    private double balance; // Data hidden
    public void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
    public double getBalance() { return balance; } // Controlled access
}

class Animal {
    void eat() { System.out.println("Animal eats"); }
}
class Dog extends Animal { // Dog inherits from Animal
    void bark() { System.out.println("Dog barks"); }
}
// Dog objects can use eat() method inherited from Animal
Dog myDog = new Dog();
myDog.eat(); // Output: Animal eats

interface Shape {
    void draw();
}
class Circle implements Shape {
    public void draw() { System.out.println("Drawing Circle"); }
}
class Square implements Shape {
    public void draw() { System.out.println("Drawing Square"); }
}
// Runtime polymorphism
Shape s1 = new Circle();
Shape s2 = new Square();
s1.draw(); // Calls Circle's draw()
s2.draw(); // Calls Square's draw()

abstract class Vehicle {
    abstract void drive(); // Abstract method, no implementation
    void startEngine() { System.out.println("Engine started"); } // Concrete method
}
class Car extends Vehicle {
    void drive() { System.out.println("Car is driving"); } // Implements abstract method
}
// Vehicle myCar = new Vehicle(); // Error: Cannot instantiate abstract class
Car myCar = new Car();
myCar.drive(); // Output: Car is driving

class Book {
    String title;
    String author;
    public Book() { // Default constructor
        this.title = "Unknown";
        this.author = "Anonymous";
    }
    public Book(String title, String author) { // Parameterized constructor
        this.title = title;
        this.author = author;
    }
}
Book book1 = new Book(); // Uses default constructor
Book book2 = new Book("1984", "George Orwell"); // Uses parameterized constructor

class Person {
    String name;
    int age;
    public Person(String name, int age) {
        this.name = name; // 'this.name' refers to instance variable
        this.age = age;   // 'name' and 'age' refer to parameters
    }
    void display() {
        System.out.println("Name: " + this.name + ", Age: " + this.age);
    }
}

abstract class Shape {
    abstract double getArea(); // Abstract method: no body
    void displayInfo() { System.out.println("This is a shape."); }
}
class Circle extends Shape {
    double radius;
    Circle(double radius) { this.radius = radius; }
    @Override
    double getArea() { return Math.PI * radius * radius; } // Implementation provided
}

class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; } // Overloaded by type
    int add(int a, int b, int c) { return a + b + c; } // Overloaded by number of args
}
Calculator calc = new Calculator();
System.out.println(calc.add(5, 10));      // Calls int add(int, int)
System.out.println(calc.add(2.5, 3.5));  // Calls double add(double, double)
System.out.println(calc.add(1, 2, 3));   // Calls int add(int, int, int)

class Animal {
    void makeSound() { System.out.println("Animal makes a sound"); }
}
class Dog extends Animal {
    @Override // Indicates method overriding
    void makeSound() { System.out.println("Dog barks"); }
}
Animal myAnimal = new Dog(); // Superclass reference, subclass object
myAnimal.makeSound(); // Output: Dog barks (runtime decision)

class Animal {
    String name;
    Animal(String name) { this.name = name; }
    void display() { System.out.println("Animal: " + name); }
}
class Dog extends Animal {
    String breed;
    Dog(String name, String breed) {
        super(name); // Invokes parent class constructor
        this.breed = breed;
    }
    @Override
    void display() {
        super.display(); // Calls parent's display method
        System.out.println("Breed: " + breed);
    }
}

final class ImmutablePoint { // Final class cannot be subclassed
    final int x; // Final variable, value set once
    ImmutablePoint(int x) { this.x = x; }
}
class Base {
    final void show() { System.out.println("Final method"); } // Cannot be overridden
}
// class Derived extends Base { void show() {} } // Compile-time error

class Engine {
    void start() { System.out.println("Engine started"); }
}
class Car {
    private Engine engine; // Car HAS-A Engine
    public Car() {
        this.engine = new Engine(); // Engine is a part of Car
    }
    public void drive() {
        engine.start(); // Delegate to Engine object
        System.out.println("Car is driving");
    }
}
Car myCar = new Car();
myCar.drive(); // Output: Engine started \n Car is driving

class Vehicle {
    void start() { System.out.println("Vehicle started."); }
}
class Car extends Vehicle {
    @Override
    void start() { System.out.println("Car started with a key."); }
}
class Bike extends Vehicle {
    @Override
    void start() { System.out.println("Bike started with a kick."); }
}
Vehicle v1 = new Car();  // Vehicle reference, Car object
Vehicle v2 = new Bike(); // Vehicle reference, Bike object
v1.start(); // Output: Car started with a key. (Runtime decision)
v2.start(); // Output: Bike started with a kick. (Runtime decision)

class Student {
    String name;
    static int studentCount = 0; // Shared by all students
    Student(String name) { this.name = name; studentCount++; }
    static void displayTotalStudents() { // Class method
        System.out.println("Total students: " + studentCount);
    }
    void displayStudentName() { // Instance method
        System.out.println("Student name: " + name);
    }
}
Student s1 = new Student("Alice");
Student s2 = new Student("Bob");
Student.displayTotalStudents(); // Output: Total students: 2
s1.displayStudentName(); // Output: Student name: Alice

class MyClass {
    int instanceVar = 10;
    void nonStaticMethod() {
        System.out.println("Non-static method called. Instance variable: " + instanceVar);
    }
    static void staticMethod() {
        // nonStaticMethod(); // Compile-time error: non-static method cannot be referenced from a static context
        MyClass obj = new MyClass(); // Create an object
        obj.nonStaticMethod();       // Call non-static method via object
    }
}
MyClass.staticMethod(); // Output: Non-static method called. Instance variable: 10