//
you're reading...
C# 3.0

Understanding C# Constructors and its types

Understanding C# Constructors and its type

What are constructors: Constructor is a special kind of method which have name same as that of class they belong and gets executed when its (class) object is created.
In other words a constructor is a class default method that gets automatically executed whenever class’s object is created or whenever class is initialized.

Consider this example
public class demo
{
public demo ()
{
//A default Constructor
}

//Class members

}

In this example, the method demo() is called the constructor of class demo, also called default constructor.
How it works: whenever you try to create an object of class or initialize a class, then the default constructor will be automatically invoked.
//Initializes the Class
demo object = new demo ();

Point to remember about constructor
1) Constructor can’t be inherited, although a derived class can class the base class constructor.
2) You have to explicitly write a default constructor while overloading constructors.
3) Concept declaring multiple constructors of a class with different sets of parameters known as Constructor overloading.
4) A constructor can be called another constructor using this()

Types of Constructor:
1) Default constructor: A constructor that takes no parameters is called a default constructor. Default constructors are invoked whenever an object is instantiated by using the new operator and no arguments are provided to new.
2) Parameterized constructor: when we initialize class members during instantiation we use parameterized constructor which is similar to default constructor butl have parameters.

Below is code example:

public class demo
{
public demo()
{
//A default Constructor
}

public demo(String Name)
{
//A parameterized Constructor having one parameter
}

public demo(String FirstName, String LastName)
{
//A parameterized Constructor having two parameters
}

//Class members

}

When you create a parameterized constructor, we need to declare a default constructor explicitly.

Access modifier for constructor:
1) Public constructor: Constructors are public by default.
2) Private constructor: It is a special instance constructor. It is commonly used in classes that contain static members only. If a class has one or more private constructors and no public constructors, then other classes (except nested classes) are not allowed to create instances of this class.
public class demo
{
private demo()
{
//A default Constructor as private
}
}
So when we will try to create object of this class, it will generate an error.
I.e. demo object = new demo () //Error

Is there any way to create object of this class.
We can instantiate the above class by declaring another public constructor that has parameters.
public class demo
{
private demo()
{
//A default Constructor as private
}
public demo(String strName): this()
{
System.Console.WriteLine(“Hello Mr. : “ + strName);
}

//Class members
}
And now you can initialize object for this class,
demo object = new demo() , which will work fine.

3) Static Constructor: A static constructor is used to initialize any static data, or to perform a action that needs to be performed only once. It is called automatically before the first instance is created or any static members are referenced.

public class demo
{
static demo()
{
//A static Constructor
// Can only access static members here.

System.Console.WriteLine(“I am a static constructor.”);
}
}
So when we create object of this class, “I am a static constructor” gets printed.
Examine the below code as well,
public class demo
{
static demo()
{
//A static Constructor
// Can only access static members here.

System.Console.WriteLine(“I am a static constructor.”);
}

public demo()
{
//A default Constructor
}

//Class members

}

This example also prints the same result, “I am a static constructor”
Point to remember about static constructor:
1) A static constructor should not be declared with any access modifier.
2) A static constructor does not accept parameters
3) A static constructor is called automatically.
4) There is no way to call a static constructor directly.

# How to call parent class constructor in derived class during inheritance
Answer: It can be achieved by using base ()
Example:
public class parent
{
public parent ()
{
//A default Constructor
}

public parent (String strName)
{
//A parameterized Constructor having one parameter
}

//Class members

}

public class child : parent
{
public child ()
{
//A default Constructor
}

public child (String strName) : base(strName)
{
//A parameterized Constructor having one parameter
}

//Class members

static void Main()
{
child object1 = new child (); //1*
child object2 = new child (“Vishal Nayan”); //2*
}

}

* Sequence is important here in which constructor is called.
1) First parent class public constructor, parent() is called then child class public constructor, child()
2) First parent (String strName) and then child (String strName).

Advertisements

About Vishal

Vishal Nayan is a seasoned professional with hand on Experience on Mircrosoft Technologies. He always look for challenging IT position that allows him to learn new Microsoft Technologies while utilizing experience of Project Development and Software Engineering Ethics. A MCP in WCF ,and looking forward for more.

Discussion

No comments yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Categories

Follow Vishalnayan on WordPress.com

Blog Stats

  • 211,463 hits
%d bloggers like this: