Parameterized Constructor

Introduction

A Parameterized Constructor is a special type of constructor in object-oriented programming (OOP) that allows you to initialize an object with specific values at the time of its creation. Unlike a default constructor, which takes no arguments, a parameterized constructor requires input arguments and uses them to set up the initial state of an object.

This feature offers significant advantages in terms of flexibility, control, and readability, particularly in applications where objects must be initialized with unique or meaningful values.

Purpose of Parameterized Constructors

General Syntax in Popular Languages

C++

class Person {
public:
    std::string name;
    int age;

    Person(std::string n, int a) {
        name = n;
        age = a;
    }
};

Person p("Alice", 30);

Java

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Person p = new Person("Alice", 30);

Python

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("Alice", 30)

C#

public class Person {
    public string Name;
    public int Age;

    public Person(string name, int age) {
        Name = name;
        Age = age;
    }
}

var p = new Person("Alice", 30);

Comparison: Parameterized vs Default Constructor

Overloading Constructors

Many languages support constructor overloading, allowing a class to have multiple constructors with different parameter lists.

Java Example

public class Rectangle {
    int width, height;

    // Default
    public Rectangle() {
        this(1, 1); // calls the parameterized constructor
    }

    // Parameterized
    public Rectangle(int w, int h) {
        width = w;
        height = h;
    }
}

C++ Example

class Rectangle {
public:
    int width, height;

    Rectangle() : width(1), height(1) {} // default
    Rectangle(int w, int h) : width(w), height(h) {} // parameterized
};

Constructor Chaining with this() or Delegation

Languages like Java and C# support constructor chaining using this() to call another constructor from within one:

public class Person {
    String name;
    int age;

    public Person(String name) {
        this(name, 0);  // delegate to main constructor
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Use in Dependency Injection and Frameworks

Parameterized constructors play a key role in frameworks that use constructor injection:

• In Spring (Java), constructor injection allows passing dependencies directly to the class during bean creation.
• In ASP.NET Core (C#), services are registered and resolved via constructors with parameters.
• In Python frameworks like FastAPI, parameterized constructors or __init__ methods are common for injecting services or models.

Parameterized Constructors in Data Classes (Python, Kotlin, etc.)

Python’s dataclass

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

p = Point(3, 4)  # auto-generated parameterized constructor

Kotlin

data class Point(val x: Int, val y: Int)

val p = Point(3, 4)

In both languages, parameterized constructors are generated automatically based on class properties.

Parameter Defaults and Named Parameters

Some languages support default values and named parameters, enhancing the flexibility of parameterized constructors.

Python

class Person:
    def __init__(self, name="Anonymous", age=0):
        self.name = name
        self.age = age

p1 = Person()
p2 = Person(age=25)

Kotlin

class Person(val name: String = "Unknown", val age: Int = 0)

Pros and Cons

✅ Advantages

• Objects are always initialized in a valid state
• Avoids setter methods or property mutation
• Allows constructor overloading for flexibility
• Supports dependency injection patterns
• Improves code readability and self-documentation

❌ Disadvantages

• Too many parameters can hurt readability (especially >3–4)
• Constructors with logic can violate SRP (Single Responsibility Principle)
• Can be hard to manage when adding new fields

Best Practices

• ✅ Keep parameterized constructors simple and focused on initialization only
• ✅ Consider using Builder Pattern if constructor has too many parameters
• ✅ Use meaningful parameter names to improve readability
• ✅ Leverage constructor chaining (this(...)) to avoid duplicated logic
• ✅ Avoid business logic or I/O in constructors

Summary

Related Keywords

• Builder Pattern
• Class Constructor
• Constructor Chaining
• Constructor Overloading
• Dependency Injection
• Default Constructor
• Factory Pattern
• Initialization Method
• Object Instantiation
• Singleton Pattern