துவக்கம்

1. மாறிகளை துவக்குதல்

உங்களுக்கு ஏற்கனவே தெரியும், உங்கள் வகுப்பில் பல மாறிகளை அறிவிக்கலாம், மேலும் அவற்றை அறிவிப்பது மட்டுமல்லாமல், அவற்றின் ஆரம்ப மதிப்புகளுடன் அவற்றை உடனடியாக துவக்கவும்.

இதே மாறிகள் ஒரு கன்ஸ்ட்ரக்டரிலும் துவக்கப்படலாம். இதன் பொருள், கோட்பாட்டில், இந்த மாறிகள் இரண்டு முறை மதிப்புகளை ஒதுக்கலாம். உதாரணமாக

class Cat
{
   public String name;
   public int age = -1;

   public Cat(String name, int age)
   {
     this.name = name;
     this.age = age;
   }

   public Cat()
   {
     this.name = "Nameless";
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat();

Cat cat = new Cat("Whiskers", 2);செயல்படுத்தப்படும் போது இதுதான் நடக்கும் :

• ஒரு Catபொருள் உருவாக்கப்படுகிறது
• அனைத்து நிகழ்வு மாறிகளும் அவற்றின் ஆரம்ப மதிப்புகளுடன் துவக்கப்படுகின்றன
• கட்டமைப்பாளர் அழைக்கப்பட்டு அதன் குறியீடு செயல்படுத்தப்படுகிறது.

வேறு வார்த்தைகளில் கூறுவதானால், மாறிகள் முதலில் அவற்றின் ஆரம்ப மதிப்புகளைப் பெறுகின்றன, அதன் பிறகுதான் கட்டமைப்பாளரின் குறியீடு செயல்படுத்தப்படுகிறது.

2. ஒரு வகுப்பில் மாறிகளின் துவக்க வரிசை

கன்ஸ்ட்ரக்டர் இயங்கும் முன் மாறிகள் வெறுமனே துவக்கப்படுவதில்லை - அவை நன்கு வரையறுக்கப்பட்ட வரிசையில் துவக்கப்படுகின்றன: அவை வகுப்பில் அறிவிக்கப்படும் வரிசை.

சில சுவாரஸ்யமான குறியீட்டைப் பார்ப்போம்:

public class Solution
{
   public int a = b + c + 1;
   public int b = a + c + 2;
   public int c = a + b + 3;
}

இந்த குறியீடு தொகுக்கப்படாது, ஏனெனில் aமாறி உருவாக்கப்பட்ட நேரத்தில் இன்னும் இல்லை b மற்றும் c மாறிகள் இல்லை. ஆனால் உங்கள் குறியீட்டை பின்வருமாறு எழுதலாம் - இந்த குறியீடு தொகுக்கப்பட்டு நன்றாக இயங்கும் .

public class Solution
{
   public int a;
   public int b = a + 2;
   public int c = a + b + 3;
}

ஆனால் உங்கள் குறியீடு மற்ற டெவலப்பர்களுக்கு வெளிப்படையாக இருக்க வேண்டும் என்பதை நினைவில் கொள்ளுங்கள். இது போன்ற நுட்பங்களைப் பயன்படுத்தாமல் இருப்பது நல்லது, ஏனெனில் இது குறியீட்டின் வாசிப்புத் திறனைக் குறைக்கிறது.

மாறிகளுக்கு ஒரு மதிப்பு ஒதுக்கப்படுவதற்கு முன்பு, அவை இயல்புநிலை மதிப்பைக் கொண்டிருக்கும் என்பதை இங்கே நாம் நினைவில் கொள்ள வேண்டும். வகையைப் பொறுத்தவரை int, இது பூஜ்ஜியம்.

JVM aமாறியை துவக்கும் போது, ​​அது int வகைக்கு இயல்புநிலை மதிப்பை ஒதுக்கும்: 0.

அதை அடையும் போது b, ​​ஒரு மாறி ஏற்கனவே அறியப்பட்டு ஒரு மதிப்பைக் கொண்டிருக்கும், எனவே JVM அதற்கு மதிப்பு 2 ஐ ஒதுக்கும்.

அது cமாறியை அடையும் போது, a​​மற்றும் bமாறிகள் ஏற்கனவே துவக்கப்படும், எனவே JVM ஆனது ஆரம்ப மதிப்பை எளிதாக கணக்கிடும் c: 0+2+3.

நீங்கள் ஒரு முறைக்குள் ஒரு மாறியை உருவாக்கினால், அதற்கு முன்னர் ஒரு மதிப்பை நீங்கள் ஒதுக்கியிருந்தால் தவிர, அதைப் பயன்படுத்த முடியாது. ஆனால் ஒரு வகுப்பின் மாறிகளுக்கு இது உண்மையல்ல! ஒரு வகுப்பின் மாறிக்கு ஆரம்ப மதிப்பு ஒதுக்கப்படாவிட்டால், அது இயல்புநிலை மதிப்பாக ஒதுக்கப்படும்.

3. மாறிலிகள்

பொருள்கள் எவ்வாறு உருவாக்கப்படுகின்றன என்பதை நாங்கள் பகுப்பாய்வு செய்யும் போது, ​​மாறிலிகளின் துவக்கத்தை, அதாவது மாற்றியமைப்புடன் கூடிய மாறிகள் என்பதைத் தொடுவது மதிப்பு final.

ஒரு மாறியில் மாற்றி இருந்தால் final, அதற்கு ஆரம்ப மதிப்பை ஒதுக்க வேண்டும். இது உங்களுக்கு ஏற்கனவே தெரியும், இதில் ஆச்சரியப்படுவதற்கு ஒன்றுமில்லை.

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

உதாரணமாக:

public class Cat
{
   public final int maxAge = 25;
   public final int maxWeight;

   public Cat (int weight)
   {
     this.maxWeight = weight; // Assign an initial value to the constant
   }
}

4. ஒரு கன்ஸ்ட்ரக்டரில் குறியீடு

மற்றும் கட்டமைப்பாளர்களைப் பற்றிய இன்னும் சில முக்கியமான குறிப்புகள். பின்னர், நீங்கள் ஜாவாவைத் தொடர்ந்து கற்கும்போது, ​​பரம்பரை, வரிசைப்படுத்தல், விதிவிலக்குகள் போன்ற விஷயங்களைக் காண்பீர்கள். அவை அனைத்தும் கட்டமைப்பாளர்களின் வேலையை பல்வேறு அளவுகளில் பாதிக்கின்றன. இப்போது இந்த தலைப்புகளில் ஆழமாக மூழ்குவதில் அர்த்தமில்லை, ஆனால் குறைந்தபட்சம் அவற்றைத் தொடுவதற்கு நாங்கள் கடமைப்பட்டுள்ளோம்.

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

class FilePrinter
{
   public String content;

   public FilePrinter(String filename) throws Exception
   {
      FileInputStream input = new FileInputStream(filename);
      byte[] buffer = input.readAllBytes();
      this.content = new String(buffer);
   }

   public void printFile()
   {
      System.out.println(content);
   }
}

FilePrinter கிளாஸ் கன்ஸ்ட்ரக்டரில், ஒரு கோப்பில் பைட் ஸ்ட்ரீமை உடனடியாகத் திறந்து அதன் உள்ளடக்கங்களைப் படித்தோம். இது சிக்கலான நடத்தை மற்றும் பிழைகள் ஏற்படலாம்.

அத்தகைய கோப்பு இல்லை என்றால் என்ன செய்வது? கோப்பைப் படிப்பதில் சிக்கல்கள் இருந்தால் என்ன செய்வது? அது மிகப் பெரியதாக இருந்தால் என்ன செய்வது?

சிக்கலான தர்க்கம் என்பது பிழைகளின் அதிக நிகழ்தகவைக் குறிக்கிறது மற்றும் குறியீடு விதிவிலக்குகளை சரியாகக் கையாள வேண்டும் என்பதாகும்.

எடுத்துக்காட்டு 1 - வரிசைப்படுத்தல்

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

ஆனால் உங்கள் கோப்பு மற்ற கணினியில் இல்லை என்று வைத்துக்கொள்வோம். கட்டமைப்பாளரில் பிழை இருக்கும், அதை யாரும் கையாள மாட்டார்கள். இது நிரலை நிறுத்துவதற்கு மிகவும் திறமையானது.

எடுத்துக்காட்டு 2 — ஒரு வகுப்பின் புலங்களை துவக்குதல்

உங்கள் கிளாஸ் கன்ஸ்ட்ரக்டர் சரிபார்க்கப்பட்ட விதிவிலக்குகளை வீச முடியும் என்றால், அதாவது த்ரோஸ் முக்கிய வார்த்தையால் குறிக்கப்பட்டிருந்தால், உங்கள் பொருளை உருவாக்கும் முறையில் சுட்டிக்காட்டப்பட்ட விதிவிலக்குகளை நீங்கள் பிடிக்க வேண்டும்.

ஆனால் அத்தகைய முறை இல்லை என்றால் என்ன செய்வது? உதாரணமாக:

class Solution
{
   public FilePrinter reader = new FilePrinter("c:\\readme.txt");
}

கிளாஸ் கன்ஸ்ட்ரக்டர் சரிபார்க்கப்பட்ட விதிவிலக்கைFilePrinter எறியலாம் , அதாவது ஒரு பொருளை முயற்சி-பிடிப்பு பிளாக்கில் போர்த்தாமல் உங்களால் உருவாக்க முடியாது. மற்றும் ஒரு முயற்சி-பிடிப்பு தொகுதியை ஒரு முறையில் மட்டுமே எழுத முடியும்FilePrinter

5. அடிப்படை வகுப்பு கட்டமைப்பாளர்

முந்தைய பாடங்களில், பரம்பரை பற்றி கொஞ்சம் விவாதித்தோம். துரதிர்ஷ்டவசமாக, பரம்பரை மற்றும் OOP பற்றிய எங்கள் முழு விவாதமும் OOP க்கு அர்ப்பணிக்கப்பட்ட நிலைக்கு ஒதுக்கப்பட்டுள்ளது, மேலும் கட்டமைப்பாளர்களின் பரம்பரை ஏற்கனவே எங்களுக்குப் பொருத்தமானது.

உங்கள் வகுப்பு மற்றொரு வகுப்பைப் பெற்றால், உங்கள் வகுப்பின் ஒரு பொருளுக்குள் பெற்றோர் வகுப்பின் பொருள் உட்பொதிக்கப்படும். மேலும் என்ன, பெற்றோர் வர்க்கம் அதன் சொந்த மாறிகள் மற்றும் அதன் சொந்த கட்டமைப்பாளர்களைக் கொண்டுள்ளது.

அதாவது, உங்கள் வகுப்பில் பெற்றோர் வகுப்பு இருக்கும்போது, ​​அதன் மாறிகள் மற்றும் முறைகளை நீங்கள் பெறும்போது, ​​மாறிகள் எவ்வாறு துவக்கப்படுகின்றன மற்றும் கட்டமைப்பாளர்கள் அழைக்கப்படுவார்கள் என்பதை நீங்கள் அறிந்துகொள்வதும் புரிந்துகொள்வதும் மிகவும் முக்கியம்.

வகுப்புகள்

மாறிகள் துவக்கப்பட்டு கன்ஸ்ட்ரக்டர்கள் அழைக்கப்படும் வரிசையை எப்படி அறிவது? இரண்டு வகுப்புகளுக்கான குறியீட்டை எழுதுவதன் மூலம் ஆரம்பிக்கலாம். ஒன்று மற்றொன்றைப் பெறுகிறது:

class ParentClass
{
   public String a;
   public String b;

   public ParentClass()
   {
   }
}

class ChildClass extends ParentClass
{
   public String c;
   public String d;

   public ChildClass()
   {
   }
}

மாறிகள் துவக்கப்படும் மற்றும் கட்டமைப்பாளர்கள் அழைக்கப்படும் வரிசையை நாம் தீர்மானிக்க வேண்டும். பதிவுசெய்தல் இதைச் செய்ய எங்களுக்கு உதவும்.

பதிவு செய்தல்

பதிவுசெய்தல் என்பது ஒரு நிரல் இயங்கும் போது, ​​அவற்றை கன்சோலில் அல்லது கோப்பில் எழுதுவதன் மூலம் செய்யப்படும் செயல்களைப் பதிவு செய்யும் செயல்முறையாகும்.

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

உண்மையில், இது மிகவும் கடினம் அல்ல: ஒரு சிறப்பு முறையை எழுதவும், இது மாறியை துவக்குவதற்கு பயன்படுத்தப்படும் மதிப்பைத் திருப்பித் தரும், மேலும் துவக்கத்தை பதிவு செய்யவும். குறியீடு இப்படி இருக்கலாம்:

இறுதி குறியீடு

public class Main
{
   public static void main(String[] args)
   {
      ChildClass obj = new ChildClass();
   }

   public static String print(String text)
   {
      System.out.println(text);
      return text;
   }
}

class ParentClass
{
   public String a = Main.print("ParentClass.a");
   public String b = Main.print("ParentClass.b");

   public ParentClass()
   {
      Main.print("ParentClass.constructor");
   }
}

class ChildClass extends ParentClass
{
   public String c = Main.print("ChildClass.c");
   public String d = Main.print("ChildClass.d");

   public ChildClass()
   {
      Main.print("ChildClass.constructor");
   }
}

இந்த குறியீட்டை இயக்கினால், திரையில் பின்வருமாறு உரை காட்டப்படும்:

ParentClass.a
ParentClass.b
ParentClass.constructor
ChildClass.c
ChildClass.d
ChildClass.constructor

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