OOP Interview Questions

Classes and Objects

class Car {
    string make;
    string model;

    public void Start() {
        Console.WriteLine("Starting the car.");
    }
}

Car myCar = new Car();
myCar.Start();

Types of OOP

Encapsulation

class BankAccount {
    private double balance;

    public void Deposit(double amount) {
        balance += amount;
    }

    public void Withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            Console.WriteLine("Insufficient funds.");
        }
    }
}

Inheritance (HAS-A relationship)

class ElectricCar : Car {
    int batteryLevel;

    public void Charge() {
        Console.WriteLine("Charging the electric car.");
    }
}

Polymorphism(IS-A relationship)

class Program {
    static void Main() {
        Car car1 = new Car();
        Car car2 = new ElectricCar();

        car1.Start(); // Outputs: Starting the car.
        car2.Start(); // Outputs: Starting the car.
    }
}

Types of Polymorphism

1. Compile-Time Polymorphism (Static Polymorphism)

2. Run-Time Polymorphism (Dynamic Polymorphism)

1. Compile-Time Polymorphism (Static Polymorphism)

• Method Overloading: This occurs when multiple methods in the same class have the same name but different parameters (type, number, or both). The compiler determines which method to call based on the method signature at compile time.

• Example of Method Overloading:

public class Calculator {
    public int Add(int a, int b) {
        return a + b;
    }

    public int Add(int a, int b, int c) {
        return a + b + c;
    }
}

class Program {
    static void Main(string[] args) {
        Calculator calc = new Calculator();
        Console.WriteLine(calc.Add(5, 10)); // Calls the first Add method
        Console.WriteLine(calc.Add(5, 10, 15)); // Calls the second Add method
    }
}

• Operator Overloading: This allows developers to define custom behavior for operators (like +, -, etc.) when applied to user-defined types.

• Example of Operator Overloading:

public class Complex {
    public double Real { get; set; }
    public double Imaginary { get; set; }

    public static Complex operator +(Complex c1, Complex c2) {
        return new Complex { Real = c1.Real + c2.Real, Imaginary = c1.Imaginary + c2.Imaginary };
    }
}

2. Run-Time Polymorphism (Dynamic Polymorphism)

• Method Overriding: This occurs when a derived class provides a specific implementation of a method that is already defined in its base class. The base class method must be marked as virtual, and the derived class method must use the override keyword.

• Example of Method Overriding:

public class Animal {
    public virtual void Speak() {
        Console.WriteLine("Animal speaks");
    }
}

public class Dog : Animal {
    public override void Speak() {
        Console.WriteLine("Dog barks");
    }
}

public class Cat : Animal {
    public override void Speak() {
        Console.WriteLine("Cat meows");
    }
}

class Program {
    static void Main(string[] args) {
        Animal myAnimal;

        myAnimal = new Dog();
        myAnimal.Speak(); // Outputs: Dog barks

        myAnimal = new Cat();
        myAnimal.Speak(); // Outputs: Cat meows
    }
}

Abstract Classes and Interfaces

abstract class Vehicle {
    public abstract void Start();
}

interface IElectric {
    void Charge();
}

class Tesla : Vehicle, IElectric {
    public override void Start() {
        Console.WriteLine("Starting the Tesla.");
    }

    public void Charge() {
        Console.WriteLine("Charging the Tesla.");
    }
}

Benefits of OOP in C#

• Modularity: OOP allows breaking a program into smaller, more manageable modules (classes).

• Code Reuse: Inheritance enables reusing existing code, reducing development time and effort.

• Extensibility: OOP makes it easier to add new features to an application.

• Maintainability: OOP promotes better code organization and readability, making it easier to maintain and update.