மாறிகளுடன் பணிபுரியும் நுணுக்கங்கள்

1. மாறிலிகள்

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

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

final Type name = value;

நீங்கள் ஒரு மாறிக்கு வேறு மதிப்பை ஒதுக்க முயற்சித்தால் final, உங்கள் நிரல் தொகுக்கப்படாது.

ஒரு finalமாறி அறிவிக்கப்படும்போது துவக்கப்பட வேண்டும் (அதற்கு ஒரு மதிப்பு ஒதுக்கப்பட வேண்டும்). இந்த விதிக்கு ஒரு விதிவிலக்கு உள்ளது: நீங்கள் ஒரு நிலையான வகுப்பு மாறியின் துவக்கத்தை ஒரு கட்டமைப்பாளருக்கு நகர்த்தலாம். ஆனால் நிலை 10ல் இதைப் பற்றி அறிந்து கொள்வீர்கள் .

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

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

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

உதாரணமாக:

final int[] data = {1, 2, 3, 4, 5, 6};

data = {6, 7, 8, 9};

data[0] = 0;
data[1] = 0;
data[2] = 0;

உலகளாவிய மாறிலிகள்

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

எடுத்துக்காட்டுகள்:

class Solution
{
   public static final String SOURCE_ROOT = "c:\\projects\\my\\";
   public static final int DISPLAY_WIDTH = 1024;
   public static final int DISPLAY_HEIGHT = 768;
}

2. மாறி நிழல்

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

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

உதாரணமாக:

public class Solution
{
   public int count = 0;
   public int sum = 0;

   public void add(int data)
   {
     sum = sum + data;
     int sum = data * 2;
     count++;
   }
}

count
count, sum
count, sum
count, sum
count, sum, data
count, sum, data
count, sum, data
count, sum, data
count, sum

முறையில் add, பெயரிடப்பட்ட ஒரு உள்ளூர் மாறியை அறிவித்தோம் sum. முறையின் இறுதி வரை, இது நிகழ்வு மாறியை நிழலாடுகிறது (அல்லது முகமூடிகள் ) sum.

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

this.name

பெயர் முரண்பாடு வெற்றிகரமாக தீர்க்கப்பட்டதற்கான எடுத்துக்காட்டு இங்கே:

public class Solution
{
   public int count = 0;
   public int sum = 0;

   public void add(int data)
   {
     int sum = data * 2;
     this.sum = this.sum + data;
     count++;
   }
}

this.count
this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum, data
this.count, this.sum, data, sum
this.count, this.sum, data, sum
this.count, this.sum, data, sum
this.count, this.sum

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

ஒரு நிகழ்வு மாறியை விட நிலையான வகுப்பு மாறி நிழலாடப்பட்டால், நீங்கள் அதை thisமுக்கிய சொல்லை விட வகுப்பின் பெயரின் மூலம் அணுக வேண்டும்:

ClassName.name

உதாரணமாக:

public class Solution
{
   public static int count = 0;
   public static int sum = 0;

   public void add(int data)
   {
     int sum = data * 2;
     Solution.sum = Solution.sum + data;
     count++;
   }
}

Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum, data
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum

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

3. ஒரு forவளையத்திற்குள் மாறிகள்

மேலும் ஒரு சிறிய ஆனால் சுவாரஸ்யமான உண்மை.

ஒரு மாறி ஒரு சிறப்பு வழியில் அறிவிக்கப்படும் இடமும் உள்ளது - ஒரு forவளையத்திற்குள் .

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

forசரியான பதில்: ஒரு லூப்பின் தலைப்பில் அறிவிக்கப்பட்ட ஒரு மாறி, லூப்பின் உடலிலும் லூப்பின் தலைப்பிலும்for மட்டுமே தெரியும் .

உதாரணமாக:

public static void main(String[] args)
{
   int a = 0;

   for (int i = 0; i < 10; i++)
   {
     System.out.println(i);
   }

   System.out.println("end");
}

a
a
a, i
a, i
a, i
a
a
a

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

உதாரணமாக:

public static void main(String[] args)
{
   int a = 0;

   for (int i = 0; i < 10; i++)
   {
     System.out.println(i);
   }

   for (int i = 0; i < 10; i++)
   {
     System.out.println(i);
   }

   System.out.println("end");
}

a
a
a, i
a, i
a, i
a
a
a, i
a, i
a, i
a
a
a