Constructor Overloading

Constructor Overloading is same as that of method overloading. The only difference between constructor overloading and method overloading is, In method overloading we'll overload methods, in constructor overloading we'll overload constructors. Having multiple constructor with same name but each constructor having either total number of parameter differents or datatype of the parameters different is known as Constructor Overloading.

CODE

EG 1 . Creating Rectangle class with constructor.

class Program {
    static void Main() {
        //Invoking constructor with 4 Parameters
        Rectangle wall = new Rectangle(5, 6, 7, 2.8);
        wall.RectangleCalculation();
        Console.WriteLine(); //Giving empty line
        //Invoking constructor with 3 Parameters
        Rectangle cupboard = new Rectangle(7,8,9);
        cupboard.RectangleCalculation();
        Console.WriteLine();
        //Invoking constructor with 1 Parameter
        Rectangle monitor = new Rectangle(10);
        monitor.RectangleCalculation();
        Console.WriteLine();
        //Invoking default constructor.
        Rectangle door = new Rectangle();
        door.RectangleCalculation();
        Console.WriteLine();
    }
}

class Rectangle {
    public double length, width, height, density;
    //Constructor Overloading
    public Rectangle(double l,double w,double h,double d) {
        length = l;
        width = w;
        height = h;
        density = d;
    }
    public Rectangle(double l, double w, double h) {
        length = l;
        width = w;
        height = h;
        density = 1;
    }
    public Rectangle(double l) {
        length = l;
        width = 1;
        height = 1;
        density = 1;
    }
    //Default Constructor
    public Rectangle() {
        length = 1;
        width = 1;
        height = 1;
        density = 1;
    }

    public double Area() {
        return length * width;
    }
    public double Perimeter() {
        return 2 * (length+width);
    }
    public double Volume() {
        return Area() * height;
    }
    public double Weight() {
        return Volume() * density;
    }
    public void RectangleCalculation() {
        Console.WriteLine(Area());
        Console.WriteLine(Perimeter());
        Console.WriteLine(Volume());
        Console.WriteLine(Weight());
    }
}

OUTPUT
30
22
210
588

56
30
504
504

10
22
10
10

1
4
1
1

CODE EXPLANATION
In the above code inside Rectangle class, we created 4 Rectangle constructor overloads(Even Default constructor will also be taken as a overload). In main method while creating instance of Rectangle class depending on the number of arguments what we going to pass, system will invoke respective constructor overload.


What is the use of Constructor, Constructor overloading and where to use it?
constructors are used to automatically assign the values of fields present inside a class.
In order to explain this let us take the above code example,
If we didn't create Rectangle class constructor then only way to assign the values to fields is manually calling objectName.VariableNames which consumes lot of time. Just because we created Rectangle constructor, we can only pass the values inside () which presents after class name, system will automatically invoke constructor overload and assign the values to its respective fields. Just because this operation is taking place automatically we are saving up lot of time.

Exercises
1. Create a Traingle class with 5 constructor overloads.


(Click Here, For more exercises)