Constructor
is a special method of a class which will invoke automatically whenever
instance or object of class is created. Constructors are responsible for object
initialization and memory allocation of its class. If we create any class
without constructor, the compiler will automatically create one default constructor
for that class. There is always at least one constructor in every class.
Here
you need to remember that a class can have any number of constructors and constructors
don’t have any return type, not even void and within a class we can create only
one static constructor.
Generally
constructor name should be same as class name. If we want to create constructor
in a class we need to create a constructor method name same as class name check
below sample method for constructor
class SampleA
{
public SampleA()
{
Console.WriteLine("Sample
A Test Method");
}
}
|
Types of Constructors
Basically
constructors are 5 types those are
1. Default Constructor
2. Parameterized
Constructor
3. Copy Constructor
4. Static Constructor
5. Private Constructor
Default Constructor
A
constructor without having any parameters called default constructor. In this
constructor every instance of the class will be initialized without any
parameter values like as shown below
using System;
namespace ConsoleApplication3
{
class Sample
{
public string
param1, param2;
public Sample()
// Default Constructor
{
param1 = "Welcome";
param2 = "Vamsi";
}
}
class Program
{
static void Main(string[] args)
{
Sample obj=new Sample();
// Once object of class created
automatically constructor will be called
Console.WriteLine(obj.param1);
Console.WriteLine(obj.param2);
Console.ReadLine();
}
}
}
|
When
we run above program it will show output like as shown below
Output
Welcome
Vamsi
|
Parameterized Constructors
A constructor with at
least one parameter is called as parameterized constructor. In parameterized
constructor we can initialize each instance of the class to different values
like as shown below
using System;
namespace ConsoleApplication3
{
class Sample
{
public string
param1, param2;
public Sample(string
x, string y) // Declaring
Parameterized constructor with Parameters
{
param1 = x;
param2 = y;
}
}
class Program
{
static void Main(string[] args)
{
Sample obj=new Sample("Welcome","Vamsi"); // Parameterized
Constructor Called
Console.WriteLine(obj.param1 +" to "+ obj.param2);
Console.ReadLine();
}
}
}
|
When
we run above program it will show output like as shown below
Output
Welcome
to Vamsi
|
Constructor Overloading
In c# we can overload
constructor by creating another constructor with same method name and different
parameters like as shown below
using System;
namespace ConsoleApplication3
{
class Sample
{
public string
param1, param2;
public Sample()
// Default Constructor
{
param1 = "Hi";
param2 = "I
am Default Constructor";
}
public Sample(string
x, string y) // Declaring
Parameterized constructor with Parameters
{
param1 = x;
param2 = y;
}
}
class Program
{
static void Main(string[] args)
{
Sample obj = new Sample();
// Default Constructor will Called
Sample obj1=new Sample("Welcome","Vamsi"); // Parameterized
Constructor will Called
Console.WriteLine(obj.param1 + ", "+obj.param2);
Console.WriteLine(obj1.param1 +" to " + obj1.param2);
Console.ReadLine();
}
}
|
When
we run above program it will show output like as shown below
Output
Hi,
I am Default Constructor
Welcome
to Vamsi
|
Copy Constructor
A parameterized
constructor that contains a parameter of same class type is called as copy
constructor. Main purpose of copy constructor is to initialize new instance to
the values of an existing instance. Check below example for this
using System;
namespace ConsoleApplication3
{
class Sample
{
public string
param1, param2;
public Sample(string
x, string y)
{
param1 = x;
param2 = y;
}
public Sample(Sample
obj) //
Copy Constructor
{
param1 = obj.param1;
param2 = obj.param2;
}
}
class Program
{
static void Main(string[] args)
{
Sample obj = new Sample("Welcome",
"Vamsi"); // Create
instance to class Sample
Sample obj1=new Sample(obj); // Here
obj details will copied to obj1
Console.WriteLine(obj1.param1 +" to " + obj1.param2);
Console.ReadLine();
}
}
}
|
When
we run above program it will show output like as shown below
Output
Welcome
to Vamsi
|
Static Constructor
When we declared
constructor as static it will be invoked only once for any number of instances
of the class and it’s during the creation of first instance of the class or the
first reference to a static member in the class. Static constructor is used to
initialize static fields of the class and to write the code that needs to be
executed only once.
using System;
namespace ConsoleApplication3
{
class Sample
{
public string
param1, param2;
static Sample()
{
Console.WriteLine("Static
Constructor");
}
public Sample()
{
param1 = "Sample";
param2 = "Instance
Constructor";
}
}
class Program
{
static void Main(string[] args)
{
// Here Both Static and instance
constructors are invoked for first instance
Sample obj=new Sample();
Console.WriteLine(obj.param1 + " " + obj.param2);
// Here only instance constructor
will be invoked
Sample obj1 = new Sample();
Console.WriteLine(obj1.param1 +" " + obj1.param2);
Console.ReadLine();
}
}
}
|
When
we run above program we will get output like as shown below
Output
Static
Constructor
Sample
Instance Constructor
Sample
Instance Constructor
|
Importance points of static constructor
- Static constructor will not accept any
parameters because it is automatically called by CLR.
- Static constructor will not have any access
modifiers.
- Static constructor will execute
automatically whenever we create first instance of class
- Only one static constructor will allowed.
Private Constructor
Private
constructor is a special instance constructor used in a class that contains
static member only. If a class has one or more private constructor and no
public constructor then other classes is not allowed to create instance of this
class this mean we can neither create the object of the class nor it can be
inherit by other class. The main purpose of creating private constructor is
used to restrict the class from being instantiated when it contains every
member as static.
using System;
namespace ConsoleApplication3
{
public class Sample
{
public string
param1, param2;
public Sample(string
a,string b)
{
param1 = a;
param2 = b;
}
private Sample()
// Private Constructor Declaration
{
Console.WriteLine("Private
Constructor with no prameters");
}
}
class Program
{
static void Main(string[] args)
{
// Here we don't have chance to
create instace for private constructor
Sample obj = new Sample("Welcome","to Vamsi");
Console.WriteLine(obj.param1 +" " + obj.param2);
Console.ReadLine();
}
}
}
|
Output
Welcome
to Vamsi
|
In above method we can create object of class with
parameters will work fine. If create object of class without parameters it will
not allow us create.
// it will works fine
Sample obj = new Sample("Welcome","to Vamsi");
// it will not work because of
inaccessability
Sample obj=new Sample();
|
Important
points of private constructor
-
One use of private construct is when we
have only static member.
-
Once we provide a constructor that is
either private or public or any, the compiler will not allow us to add public
constructor without parameters to the class.
-
If we want to create object of class even
if we have private constructors then we need to have public constructor along
with private constructorPrivate Constructor
When a constructor is created with a private specifier, it is not possible for other classes to derive from this class,
neither is it possible to create an instance of this class. They are usually used in classes that contain static members
only. Some key points of a private constructor are:
- One use of a private constructor is when we have only static members.
- It provides an implementation of a singleton class pattern
- Once we provide a constructor that is either private or public or any, the compiler will not add the parameter-less public constructor to the class.
Now let us see it practically.
using System;
namespace defaultConstractor
{
public class Counter
{
private Counter() //private constrctor declaration
{
}
public static int currentview;
public static int visitedCount()
{
return ++ currentview;
}
}
class viewCountedetails
{
static void Main()
{
// Counter aCounter = new Counter(); // Error
Console.WriteLine("-------Private constructor example by vithal wadje----------");
Console.WriteLine();
Counter.currentview = 500;
Counter.visitedCount();
Console.WriteLine("Now the view count is: {0}", Counter.currentview);
Console.ReadLine();
}
}
}
Now run the application; the output is:
No comments:
Post a Comment