43 Must-known OOPs Interview Questions & Answers

Here are the top 43 OOPs interview questions and answers for beginners and professionals.

Other Interview Questions – C#, SQL

OOPs Interview Questions And Answers

Download all Questions as .PDF

What is OOPs?

Object-Oriented Programming (OOP) is a way of writing programs using “objects,” which are like building blocks. Each object can hold data (attributes) and actions (methods) that work on the data. It makes easier to manage complex programs by breaking them into smaller, reusable parts.

The main principles of OOPs are – Encapsulation, Abstraction, Inheritance, Polymorphism.

What is Class?

A class is a blueprint for creating objects. It defines the attributes (data) and methods (actions) that the objects created from the class will have. Classes help organize and structure code by grouping related data and functions together.

class Demo
{
    // Method of the class
    public void DisplayInfo()
    {
        Console.WriteLine("Welcome");
    }
} 

What is Object?

An object is a self-contained unit that holds both data and actions. The data is called attributes, and the actions are called methods. Objects are like real-world things with properties and behaviors.

// Define a class named Car
class Car
{
    // Properties of the class
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }

    // Method of the class
    public void DisplayInfo()
    {
        Console.WriteLine($"Car: {Year} {Make} {Model}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Create an object of the Car class
        Car myCar = new Car();

        // Set the properties of the object
        myCar.Make = "Toyota";
        myCar.Model = "Camry";
        myCar.Year = 2020;

        // Call the method of the object
        myCar.DisplayInfo();
    }
} 

What is the difference between a Class and an Object?

What is Encapsulation?

Encapsulation means that a group of related properties, methods, and other memebers are treated as a single unit or object. It helps protect the data by restricting direct access from outside the object, allowing it to be accessed or modified only through defined methods. This is achieved by using access modifiers like private, public, protected, internal.

// Encapsulation
class Person
{
    // Encapsulated private fields
    private string name;

    // Public methods to access and modify private fields (encapsulation)
    public void SetName(string newName)
    {
        name = newName;
    }

    public string GetName()
    {
        return name;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Person person = new Person();

        // Using encapsulation to set and get Name
        person.SetName("John");
        Console.WriteLine("Name: " + person.GetName());
    }
} 

What is Abstraction?

Abstration means hiding the unnecessary details and showing only the essential features of an object.

In C#, we can implement the abstraction OOPs principle in two ways:

1. Using Interface
2. Using Abstract Classes and Abstract Methods

// Abstract class
abstract class Animal
{
    // Abstract method (no body)
    public abstract void MakeSound();

    // Regular method
    public void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}

// Interface
interface IAnimal
{
    void Eat();
}

// Derived class implementing abstract class and interface
class Dog : Animal, IAnimal
{
    // Providing implementation of abstract method
    public override void MakeSound()
    {
        Console.WriteLine("Bark");
    }

    // Implementing interface method
    public void Eat()
    {
        Console.WriteLine("Eating...");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Dog myDog = new Dog();

        // Calling methods
        myDog.MakeSound(); // Output: Bark
        myDog.Sleep();     // Output: Sleeping...
        myDog.Eat();       // Output: Eating...
    }
} 

Difference between Encapsulation and Abstraction

What is Inheritance?

Inheritance allows a new class to inherit properties and methods from an existing class. This promotes code reusability and establishes a relationship between classes. The class that is inherited from is called the base class (or parent class), and the class that inherits is called the derived class (or child class).

// Base class (Parent class)
class Animal
{
    public void Eat()
    {
        Console.WriteLine("Eating...");
    }
}

// Derived class (Child class)
class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("Barking...");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Dog myDog = new Dog();

        // Calling method from the base class
        myDog.Eat(); // Output: Eating...

        // Calling method from the derived class
        myDog.Bark(); // Output: Barking...
    }
} 

What is Polymorphism?

Polymorphism allows a method to be defined in multiple ways in a class, enabling it to behave differently based on the object that invokes it.

Method overloading is achieved in three ways:

• Different number of parameters
• Different types of parameters
• Different order of parameters

Types of Polymorphism:

1. Compile-time Polymorphism: Also called as Static Polymorphism/ Method Overloading/ Early Binding. It Allows multiple methods in the same class to have the same name but different parameters. Achieved through method overloading and operator overloading.
▼ Show example

class MathOperations
{
    // Method to add two integers
    public int Add(int a, int b)
    {
        return a + b;
    }

    // Method to add three integers
    public int Add(int a, int b, int c)
    {
        return a + c + c;
    }
}

class Program
{
    static void Main(string[] args)
    {
        MathOperations math = new MathOperations();

        Console.WriteLine(math.Add(1, 2));        // Output: 3
        Console.WriteLine(math.Add(1, 2, 3));     // Output: 6
    }
} 

The MathOperations class has two Add methods with different parameters. The correct method is chosen at compile-time based on the arguments provided.




2. Run-time Polymorphism: Also called as Dynamic Polymorphism/ Method Overriding/ Late Binding. It Allows a subclass to provide a specific implementation of a method that is already defined in its superclass. Achieved through method overriding, typically using inheritance and interfaces.
▼ Show example

class Animal
{
    // Virtual method
    public virtual void MakeSound()
    {
        Console.WriteLine("Some generic animal sound");
    }
}

class Dog : Animal
{
    // Overriding the virtual method
    public override void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}

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

        myAnimal = new Dog();
        myAnimal.MakeSound();  // Output: Bark
    }
} 

The Animal class has a virtual method MakeSound. The Dog class override the MakeSound method to provide specific implementations. At runtime, the appropriate method is called based on the object type.

Can method overloading have different return type in C#?

If both methods have the same parameter types, but different return type, then it is not possible. you cannot declare two methods with the same signature and different return type.

Method overloading primarily depends on having different parameter lists (different number or types of parameters). The parameter lists must differ, then you can have method overloading with different return type, see the below example.

// Method with int return type
public int Add(int a, int b)
{
	return a + b;
}

// Method with double return type
// This will cause a compilation error because the parameter list is the same
public double Add(int a, int b)
{
	return a + b;
} 

// Method to add two integers
public int Add(int a, int b)
{
	return a + b;
}

// Method to add two doubles
/* different number or types of parameters */
public double Add(double a, double b)
{
	return a + b;
} 

Can static methods be overloaded in C#?

Static methods can be overloaded but not overridden, because they belong to the class, and not to any instance of the class.

Can return type be different in method overriding C#?

An override method must have the same signature as the overridden base method. override methods support covariant return types. In particular, the return type of an override method can derive from the return type of the corresponding base method.

You cannot override a non-virtual or static method. The overridden base method must be virtual, abstract, or override.

An override declaration cannot change the accessibility of the virtual method. Both the override method and the virtual method must have the same access level modifier.

You cannot use the new, static, or virtual modifiers to modify an override method.

What is an Abstract class?

An abstract class is a class that cannot be instantiated and is meant to be inherited by other classes. It can contain abstract methods (without implementation) and regular methods (with implementation).

// Abstract class
abstract class Demo1
{
    // Abstract method (no implementation)
    public abstract void Method1();

    // Regular method
    public void Method2()
    {
        // Implementation.....
    }
}

// Derived class
class Demo2 : Demo1
{
    // Providing implementation for the abstract method
    public override void Method1()
    {
        // Implementation.....
    }
} 

Can I declare an abstract class without defining an abstract method in it?

Yes, you can have an abstract class without any abstract methods. An abstract class can contain only regular methods (with implementation), properties, fields, and other members. The purpose of an abstract class in such cases is to prevent instantiation of the class directly and to provide a common base for derived classes.

What is an Abstract method?

An abstract method is a method that is declared in an abstract class but does not have an implementation in that class.

• Abstract methods contain only the method signature (name, return type, parameters) without any body.
• They can only be declared in abstract classes.
• Any non-abstract class inheriting an abstract class must implement all its abstract methods, ensuring that they provide specific functionality.
• Abstract classes, and therefore their abstract methods, cannot be instantiated directly.

Can I declare “abstract method” in a “non-abstract class”?

No, you cannot declare an abstract method in a non-abstract class. Abstract methods can only be declared in abstract classes. This is because an abstract method does not have an implementation, and a non-abstract class is expected to be instantiable and provide full implementations for all its methods.

What is Interface?

An interface class is a blueprint for classes that defines methods and properties but does not provide their implementation. Classes that implement the interface must provide the implementation for all its members.

// Define an interface
interface IAnimal
{
    // Interface method (no implementation)
    void MakeSound();
    void Sleep();
}

// Implement the interface in a class
class Dog : IAnimal
{
    // Providing implementation for the interface methods
    public void MakeSound()
    {
        Console.WriteLine("Bark");
    }

    public void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Dog myDog = new Dog();
        myDog.MakeSound();  // Output: Bark
        myDog.Sleep();      // Output: Sleeping...
    }
} 

Can Interface have accessibility modifier?

All elements in the Interface should be public. Therefore, by default, all interface elements are public by default.

Can a class implement multiple Interfaces?

Yes, a class can implement multiple interfaces. This allows a class to inherit behaviors and contracts from more than one interface.

// First interface
interface IWalkable
{
    void Walk();
}

// Second interface
interface IRunnable
{
    void Run();
}

// Class implementing both interfaces
class Person : IWalkable, IRunnable
{
    public void Walk()
    {
        Console.WriteLine("Person is walking.");
    }

    public void Run()
    {
        Console.WriteLine("Person is running.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Person person = new Person();
        person.Walk();  // Output: Person is walking.
        person.Run();   // Output: Person is running.
    }
} 

Difference between Abstract and Interface.

What is a Constructor?

A constructor is a special method in a class that is automatically called when an object of the class is created. It is used to initialize the object’s properties.

A constructor must have the same name as the class and cannot have a return type, not even void.

class Person
{
    // Default constructor
    public Person()
    {}
} 

Can I have multiple Constructors in a Class?

Yes, you can have multiple constructors in a class. This is known as constructor overloading, where each constructor has a different parameter list (different number or types of parameters).

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    // Default constructor
    public Person()
    {
        Name = "Unknown";
        Age = 0;
    }

    // Constructor with one parameter
    public Person(string name)
    {
        Name = name;
        Age = 0;
    }

    // Constructor with two parameters
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Person person1 = new Person();
        Person person2 = new Person("Alice");
        Person person3 = new Person("Bob", 25);

        Console.WriteLine($"{person1.Name}, {person1.Age}"); // Output: Unknown, 0
        Console.WriteLine($"{person2.Name}, {person2.Age}"); // Output: Alice, 0
        Console.WriteLine($"{person3.Name}, {person3.Age}"); // Output: Bob, 25
    }
} 

What is the purpose of a constructor?

The purpose of a constructor is to initialize a new object of a class.

Key Points:

• Initialization: Sets initial values for the object’s properties.
• Setup: Performs any necessary setup tasks for the object.
• No Return Type: Constructors do not have a return type, not even void.
• Same Name as Class: Constructors must have the same name as the class.

What are the types of constructors in OOP?

There are several types of constructors – Default, Parameterized, Copy, Static, Private:

1. Default Constructor: A constructor that takes no parameters. It initializes objects with default values.
▼ Show example

class Person
{
    // Default constructor
    public Person()
    {
        // your code
    }
} 

2. Parameterized Constructor: A constructor that takes parameters to initialize objects with specific values.
▼ Show example

class Person
{
    // Parameterized constructor
    public Person(string name, int age)
    {
        // your code
    }
} 

3. Copy Constructor: A constructor that creates a new object as a copy of an existing object. C# does not have a built-in copy constructor, but you can implement one.
▼ Show example

class Person
{
    // Copy constructor
    public Person(Person person)
    {
        // your code
    }
} 

4. Static Constructor: A constructor used to initialize static members of the class. It is called once, before any instance of the class is created or any static member is accessed.
▼ Show example

class Person
{
    public static int Population;

    // Static constructor
    static Person()
    {
        Population = 0;
    }

    // Instance constructor
    public Person()
    {
        Population++;
    }
} 

5. Private Constructor: A constructor that cannot be accessed outside its class. It is used to prevent the creation of instances from outside the class, often used in singleton pattern.
▼ Show example

class Singleton
{
    private static Singleton instance = null;

    // Private constructor
    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }
} 

Can constructors be overloaded?

Yes

class Person
{
    // Default constructor
    public Person() {}

    // Constructor with one parameter
    public Person(string name) {}

    // Constructor with two parameters
    public Person(string name, int age) {}
} 

What is the difference between a constructor and a method?

What is Destructor in OOPs?

A destructor in Object-Oriented Programming (OOP) is a special member function of a class that is executed when an object of that class is destroyed. Destructors are used to perform any necessary final clean-up when an object is no longer needed, such as releasing resources like memory, file handles, or network connections and to perform any finalization steps required before the object is destroyed.

In C#, destructors are defined using a tilde (~) followed by the class name. The .NET garbage collector automatically calls the destructor before reclaiming the memory used by an object.

Note: Using IDisposable and using is often a better practice for resource management in C#.

class ResourceHolder
{
    // Constructor
    public ResourceHolder()
    {
        // Acquire resources
        Console.WriteLine("Resource acquired.");
    }

    // Destructor
    ~ResourceHolder()
    {
        // Release resources
        Console.WriteLine("Resource released.");
    }

    public void DoWork()
    {
        Console.WriteLine("Working...");
    }
}

class Program
{
    static void Main(string[] args)
    {
        ResourceHolder rh = new ResourceHolder();
        rh.DoWork();
        
        // ResourceHolder object will be cleaned up when it goes out of scope
    }
} 

What is the significance of the super keyword in inheritance?

The super keyword is significant in inheritance because it allows a derived class to access and invoke methods, properties, and constructors of its base class. This is particularly important for ensuring proper initialization and extending or modifying the behavior of base class methods in derived classes.

Although C# does not have a super keyword, the base keyword serves the same purpose.

class Animal
{
    public string Name { get; set; }

    public Animal(string name)
    {
        Name = name;
    }

    public virtual void MakeSound()
    {
        Console.WriteLine("Animal sound");
    }
}

class Dog : Animal
{
    public Dog(string name) : base(name) // Calling the base class constructor
    {
    }

    public override void MakeSound()
    {
        base.MakeSound(); // Calling the base class method
        Console.WriteLine("Dog barks");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Dog dog = new Dog("Buddy");
        dog.MakeSound(); // Output: Animal sound
                         //         Dog barks
    }
} 

Explain the “this” keyword.

The ‘this’ keyword refers to the current instance of the class in which it is used and provides a way to reference the current object.

Key Uses of this Keyword:

1. Distinguishing Between Instance Variables and Parameters: When a parameter or a local variable has the same name as an instance variable, this can be used to refer to the instance variable.
2. Calling Other Constructors: It can be used to call another constructor in the same class.
3. Passing the Current Instance: It can be used to pass the current object as a parameter to other methods.
4. Returning the Current Instance: It can be used to return the current object from a method.

class Person
{
    private string name;
    private int age;

    // Constructor
    public Person(string name, int age)
    {
        // Using 'this' to distinguish between the instance variable and the parameter
        this.name = name;
        this.age = age;
    }

    // Method to set the name
    public void SetName(string name)
    {
        // Using 'this' to refer to the instance variable
        this.name = name;
    }

    // Method to display information
    public void DisplayInfo()
    {
        // Using 'this' is optional here, as there's no ambiguity
        Console.WriteLine($"Name: {this.name}, Age: {this.age}");
    }

    // Constructor chaining using 'this'
    public Person() : this("Unknown", 0)
    {
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Creating an object using the parameterized constructor
        Person person1 = new Person("Alice", 30);
        person1.DisplayInfo(); // Output: Name: Alice, Age: 30

        // Creating an object using the default constructor
        Person person2 = new Person();
        person2.DisplayInfo(); // Output: Name: Unknown, Age: 0

        // Using the SetName method
        person2.SetName("Bob");
        person2.DisplayInfo(); // Output: Name: Bob, Age: 0
    }
} 

What are Data Types?

defines the structure, behavior, and capabilities of data, specifying the operations that can be performed and how the data is stored.

Different Kind of “Types” – Value Type, Reference Type, User-Defined Type, Abstract Type, Primitive Type, Composite Type.

1. Value Types: Types that store actual data directly. Examples: int, float, struct in C#.
▼ Show example

// Value Type (struct)
struct ExampleStruct
{
    public int Value;
}

class Program
{
    static void Main(string[] args)
    {
        // Value Type
        ExampleStruct struct1 = new ExampleStruct();
        struct1.Value = 10;
        ExampleStruct struct2 = struct1;
        struct2.Value = 20;
        Console.WriteLine(struct1.Value); // Output: 10
    }
} 



2. Reference Types: Types that store references (addresses) to the actual data rather than the data itself. Examples: Classes, arrays, strings in C#.
▼ Show example

// Reference Type (class)
class ExampleClass
{
    public int Value;
}

class Program
{
    static void Main(string[] args)
    {
        // Reference Type
        ExampleClass obj1 = new ExampleClass();
        obj1.Value = 10;
        ExampleClass obj2 = obj1;
        obj2.Value = 20;
        Console.WriteLine(obj1.Value); // Output: 20
    }
} 



3. User-Defined Types: Types that are defined by the user using the language’s class and struct mechanisms. Examples: Custom classes and structs.
4. Abstract Types: Types that cannot be instantiated directly and are meant to be inherited by other classes. Examples: Abstract classes and interfaces.
5. Primitive Types: Basic data types provided by a programming language. Examples: int, char, float, double, boolean in languages like Java and C#.
6. Composite Types: Also known as complex types, they are composed of multiple primitive types. Examples: Arrays, structures, and classes.

Difference between “Class” and “Struct” in OOPs.

What are Access modifiers/ specifiers?

Access modifiers/ specifiers are keywords to define the visibility and accessibility of classes, methods, and other members. They control how the members of a class can be accessed from other parts of the code.

Access Modifiers – Public, Private, Protected, Internal, Protected Internal, Private Protected

1. Public: Members declared as public are accessible from any other code in the same assembly or another assembly that references it.
▼ Show example

public class MyClass
{
    public int MyField; // Accessible from anywhere
} 




2. Private: Members declared as private are accessible only within the same class or struct.
▼ Show example

public class MyClass
{
    private int MyField; // Accessible only within MyClass
} 




3. Protected: Members declared as protected are accessible within the same class and by derived class instances.
▼ Show example

public class MyBaseClass
{
    protected int MyField; // Accessible within MyBaseClass and derived classes
}

public class MyDerivedClass : MyBaseClass
{
    void MyMethod()
    {
        MyField = 10; // Accessible here
    }
} 




4. Internal: Members declared as internal are accessible only within the same assembly, but not from another assembly.
▼ Show example

internal class MyClass
{
    internal int MyField; // Accessible within the same assembly
} 




5. Protected Internal: Members declared as protected internal are accessible within the same assembly or from derived classes in other assemblies.
▼ Show example

// Assembly1: Library
namespace Library
{
    public class BaseClass
    {
        protected internal int protectedInternalField;

        public BaseClass()
        {
            protectedInternalField = 10;
        }

        protected internal void ProtectedInternalMethod()
        {
            Console.WriteLine("Protected Internal Method");
        }
    }
} 




// Assembly2: Application
using Library;
using System;

namespace Application
{
    public class DerivedClass : BaseClass
    {
        public void AccessProtectedInternalMembers()
        {
            // Accessing protected internal member from base class
            Console.WriteLine($"Protected Internal Field: {protectedInternalField}");
            ProtectedInternalMethod();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            DerivedClass obj = new DerivedClass();
            obj.AccessProtectedInternalMembers();

            // Accessing protected internal member directly from an instance of the base class
            BaseClass baseObj = new BaseClass();
            baseObj.protectedInternalField = 20; // Error: Inaccessible due to its protection level
            baseObj.ProtectedInternalMethod(); // Error: Inaccessible due to its protection level
        }
    }
} 




6. Private Protected: Members declared as private protected are accessible within the same class and derived classes within the same assembly.
▼ Show example

public class MyBaseClass
{
    private protected int MyField; // Accessible within MyBaseClass and derived classes in the same assembly
}

public class MyDerivedClass : MyBaseClass
{
    void MyMethod()
    {
        MyField = 10; // Accessible here
    }
} 

What is the ‘override’ keyword used for?

The override keyword in C# is used for the following purposes:

• Extending or Modifying Base Class Methods: Allows a derived class to provide a specific implementation of a method that is already defined in its base class.
• Implementing Polymorphism: Enables runtime polymorphism, allowing the derived class method to be called through a base class reference.
• Overriding Virtual/Abstract Methods: Used to override methods marked as virtual, abstract, or override in the base class.
• Ensuring Derived Class Method Execution: Guarantees that the derived class’s version of the method is executed, even when called through a base class reference.
• Providing Specific Functionality: Allows derived classes to implement or modify behavior specific to their needs, providing more tailored functionality.

public class BaseClass
{
    public virtual void Display()
    {
        Console.WriteLine("Display method in BaseClass");
    }
}

public class DerivedClass : BaseClass
{
    public override void Display()
    {
        Console.WriteLine("Display method in DerivedClass");
    }
}

public class Program
{
    public static void Main()
    {
        BaseClass obj = new DerivedClass();
        obj.Display();  // Output: Display method in DerivedClass
    }
} 

Can I override a method that is marked as ‘override’ in a base class?

Yes

public class BaseClass
{
    public virtual void Display()
    {
        Console.WriteLine("Display method in BaseClass");
    }
}

public class DerivedClass : BaseClass
{
    public override void Display()
    {
        Console.WriteLine("Display method in DerivedClass");
    }
}

public class FurtherDerivedClass : DerivedClass
{
    public override void Display()
    {
        Console.WriteLine("Display method in FurtherDerivedClass");
    }
}

public class Program
{
    public static void Main()
    {
        BaseClass obj = new FurtherDerivedClass();
        obj.Display();  // Output: Display method in FurtherDerivedClass
    }
} 

What is Sealed Class and Sealed methods in OOPs

A sealed class and sealed methods are used to restrict inheritance and prevent further derivation or overriding. This can be useful for ensuring that a class or method’s behavior remains unchanged. This is done by sealed keyword.

1) Sealed Class – A sealed class is a class that cannot be inherited by any other class. This means you cannot create a subclass of a sealed class. It is used to prevent further inheritance and to secure the implementation of a class.

public sealed class SealedClass
{
    public void DisplayMessage()
    {
        Console.WriteLine("This is a sealed class.");
    }
}

// The following code will result in a compilation error because SealedClass is sealed
public class DerivedClass : SealedClass
{
}


class Program
{
    static void Main(string[] args)
    {
        SealedClass sealedClass = new SealedClass();
        sealedClass.DisplayMessage();
    }
} 

2) Sealed Method – A sealed method is a method in a derived class that overrides a method in a base class but cannot be further overridden by any classes that derive from the derived class.

public class BaseClass
{
    public virtual void DisplayMessage()
    {
        Console.WriteLine("Message from BaseClass");
    }
}

public class DerivedClass : BaseClass
{
    public sealed override void DisplayMessage()
    {
        Console.WriteLine("Message from DerivedClass");
    }
}

// The following code will result in a compilation error because DisplayMessage is sealed
public class FurtherDerivedClass : DerivedClass
{
    public override void DisplayMessage()
    {
        Console.WriteLine("Message from FurtherDerivedClass");
    }
}


class Program
{
    static void Main(string[] args)
    {
        DerivedClass derivedClass = new DerivedClass();
        derivedClass.DisplayMessage();
    }
} 

Difference between a Sealed class and a Sealed method

public sealed class MyClass { } 

public sealed override void MyMethod() { } 

Difference between an Abstract method & Virtual method

What is the role of an Accessor and a Mutator in OOP?

Accessors and Mutators are methods used to access and modify the private fields of a class. These methods are often referred to as “getters” and “setters.”

Accessors (Getters) – used to read the value of a private field.

Mutators (Setters) – used to modify the value of a private field.

public class Person
{
    private string name;

	// Property with Getter and Setter
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
} 

What is reflection in OOP?

Reflection allows you to obtain information about assemblies, modules, types, and members (fields, properties, methods, etc.) at runtime. This includes examining metadata about types, accessing type information, and dynamically invoking methods or accessing properties.

using System;

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public void PrintFullName()
    {
        Console.WriteLine($"{FirstName} {LastName}");
    }
}

public class Example
{
    public static void Main()
    {
		// Getting the Type object using the typeof keyword
        Type personType = typeof(Person);

        // Display type information
        Console.WriteLine("Type Name: " + personType.Name);
        Console.WriteLine("Namespace: " + personType.Namespace);

        // Display properties
        Console.WriteLine("Properties:");
        foreach (var prop in personType.GetProperties())
        {
            Console.WriteLine(" - " + prop.Name);
        }

        // Display methods
        Console.WriteLine("Methods:");
        foreach (var method in personType.GetMethods())
        {
            Console.WriteLine(" - " + method.Name);
        }
    }
} 

using System;
using System.Reflection;

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public void PrintFullName()
    {
        Console.WriteLine($"{FirstName} {LastName}");
    }
}

public class Example
{
    public static void Main()
    {
        // Create an instance of Person using reflection
        Type personType = typeof(Person);
        object personInstance = Activator.CreateInstance(personType);

        // Set properties using reflection
        PropertyInfo firstNameProp = personType.GetProperty("FirstName");
        PropertyInfo lastNameProp = personType.GetProperty("LastName");

        firstNameProp.SetValue(personInstance, "John");
        lastNameProp.SetValue(personInstance, "Doe");

        // Invoke method using reflection
        MethodInfo printMethod = personType.GetMethod("PrintFullName");
        printMethod.Invoke(personInstance, null);
    }
} 

Which of these terms defines the hiding of an object’s details from the other program?

Select from the following answers:
a) Encapsulation
b) Abstraction
c) member hiding
d) None

Answer: (a) Encapsulation

what do you mean by ‘implicit’ and ‘explicit’?

Implicit means something happens automatically without the programmer needing to specify it directly. In type conversion, an implicit conversion occurs when a value of one type is automatically converted to another type by the compiler, without needing an explicit cast by the programmer.

int intNumber = 42;
// Implicit conversion from int to double
double doubleNumber = intNumber; 

Explicit means something is done deliberately and requires specific instructions from the programmer. In type conversion, an explicit conversion requires the programmer to use a cast or a specific method to convert a value from one type to another. This is often necessary when there is a potential for data loss or when converting between incompatible types.

double doubleNumber = 42.5;
// Explicit conversion from double to int
int intNumber = (int)doubleNumber; 

Explain the ‘concept of reusability’ in OOP.

Reusability in OOP refers to the ability to use existing code components in new applications or different parts of the same application. This is achieved through several key OOP concepts, including inheritance, polymorphism, and encapsulation, which help in writing modular, maintainable, and scalable code.

Benefits of Reusability:

1. Reduced Development Time: Reusing existing components reduces the time required to develop new features or applications.
2. Increased Reliability: Reused code components are likely to be well-tested and proven in other applications, leading to more reliable software.
3. Consistency: Using the same components across different parts of an application or different projects ensures consistent behavior and interface.
4. Maintainability: Changes and bug fixes can be made in one place and automatically propagated to all instances where the component is used.

How do you test OOP code?

Approaches to Testing OOP Code:

• Unit Testing: Focuses on testing individual units (e.g., methods, classes) in isolation.
• Integration Testing: Tests the interactions between different classes and modules. Ensures that combined components work together as expected.
• System Testing: Tests the entire system as a whole. Ensures that the complete application functions as intended.
• Mocking: Replaces real objects with mock objects to isolate the unit of code being tested. Useful for testing classes that depend on external resources or other classes.

Tools for Testing OOP Code:

• Unit Testing Frameworks like NUnit, xUnit.
• Mocking Frameworks like Moq

Steps to Test OOP Code:

• Write Test Cases: Identify the methods and classes to be tested. Write test cases that cover different scenarios, including edge cases and error conditions.
• Use Assertions: Verify that the actual output matches the expected output using assertions. Common assertion methods include Assert.AreEqual, Assert.IsTrue, Assert.Throws, etc.
• Setup and Teardown: Initialize any necessary objects or state before each test (Setup). Clean up after each test to ensure tests are independent and repeatable (Teardown).
• Mock Dependencies: Use mocking frameworks to create mock objects for any dependencies. Inject mock objects into the class under test to isolate its behavior.
• Run Tests: Execute the tests using a test runner or IDE integration. Review the results and fix any failing tests.