ஜாவாவில் கன்ஸ்ட்ரக்டர்.

 

 

கன்ஸ்ட்ரகடர்கள் ஒரு ஆப்ஜெக்டின் ஸ்டேட்டை தொடக்குவிக்கப்பயன்படுகின்றது. மெத்த்ட்களை இவையும் ஒன்று அல்லது ஒன்றுக்கு மேற்பட்ட கட்டளை வரிகளைக் கொண்டிருக்கும். இந்த வரிகள் அந்த கிளாசிற்கு ஆப்ஜெக்ட் உருவாக்கும் போது இயக்கப்படுகின்றன.

கன்ஸ்ட்ரக்டரின் தேவை.

இப்பொழுது ஒரு பெட்டியை எடுத்துக்ன் கொள்வோம். அதற்கு நீளம்,அகலம்,உயரம் என வெவ்வேறு பிராப்பர்டிகள் இருக்கும். இப்பொது இந்த பெட்டியானது ஆப்ஜெக்டாக  உருவாக்கும் பொழுது மெமரியில் இதன் டைமென்சன்கள் இல்லாமல் இருக்க முடியாது. அவ்வாறு ஒரு ஆப்ஜெக்டை உருவாக்கும் பொழுது அதன் தொடக்க மதிப்புகளை இருத்த கன்ஸ்ட்ரக்டர்கள் தேவைப் படுகின்றன.

 

அவ்வாறு மதிப்பிருத்தப்படுவது நிரலாளர் களால் கன்ஸ்ட்ரக்டர் எழுதி செய்யப்படலாம் அல்ல்து ஜாவாவே டிஃபால்ட் கன்ஸ்ட்ரக்டர் மூலம் மதிப்பிருத்தும்.

எப்பொழுது கன்ஸ்ட்ரக்டர்கள் அழைக்கப்படுகின்றன.

ஒவ்வொரு தடவை ஒரு ஆப்ஜெக்ட் உருவாக்கப்படும் பொழுது கன்ஸ்ட்ரக்டர்கள் அழைக்கப்படுகின்றன.ஒரு கிளாசானது குறைந்த பட்சம் ஒரு கன்ஸ்ட்ரக்டரை கொண்டிருக்கும். அது டிஃபால்ட் கன்ஸ்ட்ரக்டர் ஆகக்கூட இருக்கலாம்.இது அழைக்கப்படும் பொழுது அதன் டேட்டா மெம்பர்கள் தொடக்க மதிப்பிருத்தப்பட பயன்படுகின்றன..

சான்று

class Geek

{  

  .......

 

  // A Constructor

  new Geek() {}

 

  .......

}

 

// We can create an object of the above class

// using the below statement. This statement

// calls above constructor.

Geek obj = new Geek();

 

கன்ஸ்ட்ரக்டர் எழுதும் விதி முறைகள்.

1.      கன்ஸ்ட்ரக்டர் ஆனது அந்த கிளாசின் பெய்ரையே கொண்டிருக்கும்.

2.      இது abstract, static மற்றும் final ஆக இருக்க முடியாது.

3.      ஆக்சஸ் மாடிஃபையர் இருத்தப்படலாம்.

கன்ஸ்ட்ரக்டர் வகைகள்.

இரண்டு வகையான கன்ஸ்ட்ரக்டர்கள் இருக்கின்றன.

 

ஆர்க்கியூமெண்ட் இல்லாத கன்ஸ்ட்ரக்டர்கள் அல்லது ஆர்க்கியூமென்டுடன் கூடிய கன்ஸ்ட்ரக்டர்கள்.

 

ஆர்க்கியூமெண்ட் இல்லாத கன்ஸ்ட்ரக்டர்கள் டிஃபால்ட் கன்ஸ்ட்ரக்டர் என அழைக்கப்படுகின்றன. நிரலாளர் ஒரு கன்ஸ்ட்ரக்டர் எழுதாத பொழுது ஜாவானது அதுவே டிஃபால்ட் கன்ஸ்ட்ரக்டரை உருவாக்குகின்றது.

டிஃபால்ட் கன்ஸ்ட்ரக்டர் டிஃபால்ட் மதிப்பிருத்த பயன்படுகின்றது உதாரணமாக 0, null போன்றவை.

 

// Java Program to illustrate calling a // no-argument constructor import java.io.*;    class Geek {     int num;     String name;

  // this would be invoked while an object

    // of that class is created.

    Geek()

    {

        System.out.println("Constructor called");

    }

}

  

class GFG

{

    public static void main (String[] args)

    {

        // this would invoke default constructor.

        Geek geek1 = new Geek();

  

        // Default constructor provides the default

        // values to the object like 0, null

        System.out.println(geek1.name);

        System.out.println(geek1.num);

    }

}

வெளியீடு

Constructor called

null

0

1.    ·  Parameterized Constructor: பாராமீட்டர்களுடன் கூடிய கன்ஸ்ட்ரக்டர்கள் இவை. எந்த பாரா மீட்டர்கள் பாஸ் செய்யபடுகின்றனவோ அவை அந்த ஆப்ஜெக்டின் டேட்டா மெம்பர்களுக்கு மதிப்பிருத்தப்படுகின்றன.

// Java Program to illustrate calling of // parameterized constructor. import java.io.*;

class Geek

{

    // data members of the class.

    String name;

    int id;

  

    // constructor would initialize data members

    // with the values of passed arguments while

    // object of that class created.

    Geek(String name, int id)

    {

        this.name = name;

        this.id = id;

    }

}

class GFG {     public static void main (String[] args)     {         // this would invoke the parameterized constructor.         Geek geek1 = new Geek("adam", 1);         System.out.println("GeekName :" + geek1.name +                            " and GeekId :" + geek1.id);     } }

வெளியீடு:

GeekName :adam and GeekId :1

 

கன்ஸ்ட்ரகடர்கள் எந்த மதிப்பையும் ரிடர்ன் செய்யாது.ஆனால் இதன் ரிடர்ன் டைப்பான void என்றும் குறிப்பிடக் கூடாது.

கன்ஸ்ட்ரக்டர் ஓவர் லோடிங்க்.

மெத்தட்க்ளை போன்றே கன்ஸ்ட்ரக்டர்களையும் ஓவர்  லோட் செய்யலாம். இது ஒரு குறிப்பிட்ட் கன்ஸ்ட்ரக்டரை அதன் பாரா மீட்டரகளின் எண்ணிக்கையை வைத்தோ அல்லது அதன் டேட்டா டைப்பை வைத்தோ அழைக்கப்படுகின்றன.

சான்று நிரல்.

 

// Java Program to illustrate constructor overloading // using same task (addition operation ) for different // types of arguments. import java.io.*;    class Geek {     // constructor with one argument     Geek(String name)     {         System.out.println("Constructor with one " +                       "argument - String : " + name);     }        // constructor with two arguments     Geek(String name, int age)     {

System.out.println("Constructor with two arguments : " +

                " String and Integer : " + name + " "+ age);

  

    }

  

    // Constructor with one argument but with different

    // type than previous..

    Geek(long id)

    {

        System.out.println("Constructor with one argument : " +

                                            "Long : " + id);

    }

}

  

class GFG

{

    public static void main(String[] args)

    {

        // Creating the objects of the class named 'Geek'

        // by passing different arguments

// Invoke the constructor with one argument of         // type 'String'.         Geek geek2 = new Geek("Shikhar");            // Invoke the constructor with two arguments         Geek geek3 = new Geek("Dharmesh", 26);            // Invoke the constructor with one argument of         // type 'Long'.         Geek geek4 = new Geek(325614567);     } }

வெளியீடு

Constructor with one argument - String : Shikhar

Constructor with two arguments - String and Integer : Dharmesh 26

Constructor with one argument - Long : 325614567

கன்ஸ்ட்ரக்டர்கள் மெத்தட்களில் இருந்து எவ்வாறு மாறுபடுகின்றன..

1.      இது கிளாசின் பெயரிலேயே இருக்க்கும்

2.      கன்ஸ்ட்ரக்டர் எதையுன் ரிடர்ன் செய்யாது. Void எனவும் குறிப்பிடக்கூடாது.

3.      ஒரு கன்ஸ்ட்ரக்டர் ஆனது அதன் ஆப்ஜெக்ட் உருவாக்கும் பொழுதே அழைக்கபடுகின்றது. மெத்தட்களை எத்தனை தடவை வேண்டுமானாலும் அழைக்கலாம்.

 

முத்து கார்த்திகேயன்,மதுரை.