C# Constructors and Methods – Overloading, Inheritance, Static vs Instance

1. Can Constructors Be Overloaded or Inherited in C#?

Answer: Constructors can be overloaded, but they cannot be inherited in C#.

A. Constructor Overloading

Constructor overloading means defining multiple constructors within the same class with different parameter lists.

Example

public class Employee
{
    public int Id;
    public string Name;

    // Parameterless Constructor
    public Employee()
    {
        Id = 0;
        Name = "Unknown";
    }

    // Parameterized Constructor
    public Employee(int id)
    {
        Id = id;
        Name = "Unknown";
    }

    // Parameterized Constructor
    public Employee(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

// Usage
Employee emp1 = new Employee();
Employee emp2 = new Employee(101);
Employee emp3 = new Employee(102, "John");

Console.WriteLine(emp1.Name);
Console.WriteLine(emp2.Id);
Console.WriteLine(emp3.Name);

Output:

Unknown
101
John

Explanation:

• new Employee() calls the parameterless constructor.

• new Employee(101) calls the constructor accepting an integer.

• new Employee(102, "John") calls the constructor accepting an integer and string.

The compiler selects the appropriate constructor based on the supplied arguments.

B. Constructor Inheritance

Constructors are not inherited by derived classes. However, a derived-class constructor can call a base-class constructor using the base keyword.

Example

public class Person
{
    public Person(string name)
    {
        Console.WriteLine("Person: " + name);
    }
}

public class Employee : Person
{
    public Employee(string name) : base(name)
    {
        Console.WriteLine("Employee Constructor");
    }
}

// Usage
Employee emp = new Employee("John");

Output:

Person: John
Employee Constructor

Execution Flow

new Employee("John")
         |
         v
Employee Constructor
         |
         | base(name)
         v
Person Constructor
         |
         v
Person Initialization
         |
         v
Employee Constructor Body
         |
         v
Employee Object Ready

Explanation:

1. new Employee("John") starts object creation.

2. base(name) invokes the Person constructor.

3. The base constructor executes first.

4. The Employee constructor body executes afterward.

The Person constructor is called, not inherited.

Key Points

• Constructors support overloading.

• Constructors cannot be inherited or overridden.

• Overloading requires different parameter signatures.

• this() calls another constructor within the same class.

• base() calls a constructor in the base class.

• Base-class constructor initialization occurs before the derived-class constructor body.

2. What Is the Difference Between Static and Instance Methods in C#?

A. Static Method

A static method belongs to the class itself rather than an individual object.

It can be called using the class name without creating an object.

B. Instance Method

An instance method belongs to an object of a class.

It requires an object reference to invoke it.

Simple Example

public class Employee
{
    public static string Company = "ABC Technologies";

    public string Name;

    // Static Method
    public static void ShowCompany()
    {
        Console.WriteLine(Company);
    }

    // Instance Method
    public void ShowEmployee()
    {
        Console.WriteLine(Name);
    }
}

// Calling Static Method
Employee.ShowCompany();

// Creating Object
Employee emp = new Employee();
emp.Name = "John";

// Calling Instance Method
emp.ShowEmployee();

Output:

ABC Technologies
John

Explanation

Static Method:

Employee.ShowCompany();

• Called using the class name.

• Does not require an object.

• Directly accesses the static Company field.

Instance Method:

emp.ShowEmployee();

• Called using an object reference.

• Can access instance fields such as Name.

• Each object can contain different values.

Execution Flow

              Employee Class
                     |
          +----------+----------+
          |                     |
          v                     v
     Static Method        Instance Method
     ShowCompany()        ShowEmployee()
          |                     |
          v                     v
   Employee.ShowCompany()  new Employee()
          |                     |
          v                     v
   No Object Required       Object Required
          |                     |
          v                     v
    ABC Technologies            John

3. Static vs Instance Methods – Comparison

4. Real-World Example – ASP.NET Core

In ASP.NET Core applications, both static and instance methods are useful.

Static Method – Utility Operation

public static class TaxHelper
{
    public static decimal CalculateTax(decimal amount)
    {
        return amount * 0.18m;
    }
}

// Usage
decimal tax = TaxHelper.CalculateTax(1000);
Console.WriteLine(tax);

Output:

180.00

The method performs a calculation without depending on any object-specific state.

Instance Method – Business Service

public class EmployeeService
{
    private readonly string _department;

    public EmployeeService(string department)
    {
        _department = department;
    }

    public void ShowDepartment()
    {
        Console.WriteLine(_department);
    }
}

// Usage
EmployeeService service =
    new EmployeeService("IT");

service.ShowDepartment();

Output:

IT

The instance method accesses the object's _department field.

In ASP.NET Core, services registered through Dependency Injection typically use instance methods because they can depend on injected services, repositories, and other dependencies.

5. Important Interview Questions

Q1. Can a static method access instance variables?

Not directly. It requires an object reference.

public class Employee
{
    public string Name = "John";

    public static void Display()
    {
        Employee emp = new Employee();
        Console.WriteLine(emp.Name);
    }
}

Q2. Can an instance method access static variables?

Yes. Instance methods can access both static and instance members.

Q3. Can static methods be overloaded?

Yes. Static methods can be overloaded with different parameter lists.

Q4. Can static methods be overridden?

No. Static methods do not support runtime polymorphism through virtual and override. However, a derived class can hide an inherited static method using new.

Q5. Can we declare static and instance methods with the same name and parameter types?

No. The static modifier alone does not make their method signatures different.

Q6. Which is better: static or instance method?

It depends on the requirement.

• Use static methods for operations that do not depend on object state.

• Use instance methods for operations that depend on object data or injected dependencies.

Final Key Points

Interview takeaway: Constructors initialize objects and can be overloaded but not inherited. Static methods operate without requiring an instance, whereas instance methods can work with object-specific state. In ASP.NET Core, instance methods are commonly used for business services, while static methods are useful for stateless utility operations.