கன்ஸ்ட்ரக்டர்
மற்றும் டெஸ்ட்ரக்டர்.
using System;
using
System.Collections.Generic;
using System.Linq;
using System.Text;
using
System.Threading.Tasks;
namespace
ConsoleApp16
{
class Employee
{
String _fName;
String _lName;
public Employee(String FName, String
LName)
{
this._fName = FName;
this._lName = LName;
}
public void PrintFullName()
{
Console.WriteLine("Full Name
is " + this._fName + " " + this._lName);
}
~Employee()
{
//Body of destructor
}
}
class Program
{
static void Main(string[] args)
{
Employee e1 = new
Employee("Muthu", "karthikeyan");
e1.PrintFullName();
Console.ReadLine();
}
}
}
எப்பொழுதெல்லாம்
ஒரு கிளாஸிற்கு ஆப்ஜெக்ட் உருவாக்கும் பொழுது நிரல் வரிகள் இயக்கப்பட வேண்டும் என்றால்
அதற்கு கன்ஸ்ட்ரக்டர் பயன்படுகின்றது.
கன்ஸ்ட்ரக்டர்
என்பது ஒரு மெதட் தான். எனினும் இதற்கென்று சில சிறப்பியல்புகள் உண்டு. கன்ஸ்ட்ரக்டர்
பெயர் கிளாஸ் பெயரிலேயே இருக்கும். இதற்கு ரிடர்ன் டைப் கிடையாது. இதற்கு பராமீட்டர்
அனுப்பலாம்.
இதை நாம்
அழைக்க வேண்டியதில்லை. கிளாஸிற்கு ஆப்ஜெக்ட் உருவாக்கும் பொழுது இது தானாக இயங்கும்.
டிஃபால்ட்
கன்ஸ்ட்ரக்டர்:
ஆர்க்யூமெண்ட்
இல்லாமல் மற்றும் அதன் பாடி (Body) இல்லாமல் எழுதப்படும் கன்ஸ்ட்ரக்டர் டிஃபால்ட் கன்ஸ்ட்ரக்டர்
ஆகும். நாம் எந்த கன்ஸ்ட்ரக்டரும் எழுதாத வரையில் இது சிஸ்டத்தால் தானாக கொடுக்கப்படுகின்றது.
ஆனால் ஒரு பராமீட்டரைஸ்டு கன்ஸ்ட்ரக்டர் நாம் எழுதினால் டிஃபால்ட் கன்ஸ்ட்ரக்டர் நாமே
எழுத வேண்டும். கன்ஸ்ட்ரக்டரை ஓவர் லோட் செய்யலாம்.
டெஸ்ட்ரக்டர்:
இதுவும்
கிளாஸ் பெயரில் இருக்கும். ஆனால் இது ஒரு ஆப்ஜெக்ட் மேற்கொண்டு பயனில் இல்லாத நிலையில்
இது அழைக்கப் படுகின்றது.
இதன்
பெயருக்கு முன்னால் ஒரு ~ சிம்பல் இருக்கும்.
இதற்கு
பராமீட்டர் அனுப்ப முடியாது. எனவே இதை ஓவர் லோட் செய்ய இயலாது.
Static Constructor
ஒரு கன்ஸ்ட்ரக்டர் static என்று குறிப்பிடப் படும் பொழுது அது ஓரே ஒரு முறை மட்டுமே அழைக்கப்ப் படும். ஒரு கிளாஸின் முதல் ஆப்ஜெக்ட் உருவாக்கும் முன்னரோ அல்லது முதல் ஸ்டேட்டிக் எலிமெண்டை அணுகுவதற்கு முன்போ அழைக்கப்படும். இது ஸ்டேடிக் ஃபீயெல்டை initiate செய்யப்பயன்படுகின்றது.
ஒரு கன்ஸ்ட்ரக்டர் static என்று குறிப்பிடப் படும் பொழுது அது ஓரே ஒரு முறை மட்டுமே அழைக்கப்ப் படும். ஒரு கிளாஸின் முதல் ஆப்ஜெக்ட் உருவாக்கும் முன்னரோ அல்லது முதல் ஸ்டேட்டிக் எலிமெண்டை அணுகுவதற்கு முன்போ அழைக்கப்படும். இது ஸ்டேடிக் ஃபீயெல்டை initiate செய்யப்பயன்படுகின்றது.
மேலும் சில தகவல்கள்:
- ஸ்டேட்டிக் கன்ஸ்ட்ரகடர் பராமீட்டர் ஏதையேதும் ஏற்காது.
- இது ஒரு கிளாஸின் முதல் இன்ஸ்டன்ஸ் உருவாக்கும் முன்னரே தானாக அழைக்கப்படும்.
- இதை நம்மால் நேரடியாக அழைக்க முடியாது.
- எப்பொழுது இது இயக்கபடுவது என்பதை பயனர் தீர்மானிக்க முடியாது.
சான்று நிரல்:
using System;
namespace
staticConstructor
{
public
class employee
{
static employee() // Static constructor declaration{Console.WriteLine("The
static constructor ");
}
public
static void Salary()
{
Console.WriteLine();
Console.WriteLine("The Salary method");
}
}
class
details
{
static void Main()
{
Console.WriteLine("----------Static constructor example by karthikeyan------------------");
Console.WriteLine();
employee.Salary();
Console.ReadLine();
}
}
}
பிரைவேட்
கன்ஸ்ட்ரக்டர்:
PRIVATE என்ற ACCESS SPECIFIER உள்ள CONSTRUCTOR ஆனது PRIVATE CONSTRUCTOR எனப்படுகின்றது. PRIVATE CONSTRUCTOR –களுக்கு ஆப்ஜெக்ட் உருவாக்கவோ அல்லது INHERIT செய்யப்படவோ இயலாது.அந்த க்ளாஸின் உள்ளேயே தான் ஆப்ஜெக்ட் உருவாக்க வேண்டும்.
சான்று நிரல்:
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();
}
}
}
Copy Constructor
ஏற்கனவே உள்ள ஒரு ஆப்ஜெக்டின் மதிப்புகளை புதிய ஆப்ஜெக்டுக்கு மதிப்பிருத்த காப்பி கன்ஸ்ட்ரக்டர் பயன்படுகின்றது.
Syntax:
public employee(employee emp)
{
name=emp.name;
age=emp.age;
}
ஏற்கனவே உள்ள ஒரு ஆப்ஜெக்டின் மதிப்புகளை புதிய ஆப்ஜெக்டுக்கு மதிப்பிருத்த காப்பி கன்ஸ்ட்ரக்டர் பயன்படுகின்றது.
Syntax:
public employee(employee emp)
{
name=emp.name;
age=emp.age;
}
employee emp1=new employee (emp2);
இப்பொழுது emp2 என்ற ஆப்ஜெக்டின் மதிப்புகள் emp1 என்ற
ஆப்ஜெக்ட்டிற்கு மதிப்பிருத்தப்படுகின்றது.
using System;
namespace copyConstractor
{
class employee
{
private string name;
private int age;
public employee(employee emp) // declaring Copy
constructor.
{
name = emp.name;
age = emp.age;
}
public employee(string name, int age) // Instance
constructor.
{
this.name =
name;
this.age =
age;
}
public string Details
// Get deatils of employee
{
get
{
return " The age of " + name +" is
"+ age.ToString();
}
}
}
class empdetail
{
static void Main()
{
employee emp1
= new employee("Vithal", 23); // Create a new
employee object.
employee emp2 = new employee(emp1);
// here is
emp1 details is copied to emp2.
Console.WriteLine(emp2.Details);
Console.ReadLine();
}
}
}
முத்து கார்த்திகேயன்,மதுரை.
No comments:
Post a Comment