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

மாறிலிகள்

"அமிகோ, ஜாவாவில் எல்லா மாறிகளையும் மாற்ற முடியாது என்பது உங்களுக்குத் தெரியுமா?"

"அது எப்படி, கிம்? உண்மையில், 'மாறி' என்ற வார்த்தையே மாற்றத்தைப் பற்றி பேசுகிறது."

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

"அவை எதற்காக?"

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

"நீங்கள் ஒரு பெயர், காரின் நிறம் அல்லது வாரத்தின் ஒரு நாளின் பெயர் போன்றவற்றைச் சொல்கிறீர்களா?"

"உனக்கு சரியான யோசனை கிடைத்துள்ளது. எதையும் மாற்றக்கூடாது."

"இந்த மாறிலிகள் ஜாவாவில் எப்படி இருக்கும்?"

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

final Type name = value;

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

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

"நீங்கள் ஒரு finalமாறியை அறிவித்தாலும் அதற்கு மதிப்பை ஒதுக்காவிட்டால் என்ன செய்வது?"

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

"அது எல்லாம் finalமாறிலி அல்ல. முக்கிய வார்த்தைகளின் எண்ணிக்கையைக் குறைக்க, ஜாவா டெவலப்பர்கள் finalமாறிலிகளை அறிவிப்பதற்கும் மேலாக இந்த வார்த்தையைப் பயன்படுத்துகின்றனர். 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;
}

மாறக்கூடிய நிழல்

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

"எனக்கு தெரியும்!"

"ஆனால் உங்களுக்குத் தெரியாதது என்னவென்றால், ஒரு வகுப்பில் உள்ள மாறிகள் மற்றும் ஒரு முறையின் உள்ளூர் மாறிகள் ஒரே பெயரைக் கொண்டிருக்கலாம்.

உதாரணமாக:

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, sum
count, sum
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.sum
this.count, this.sum
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

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

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

"இதைப் பற்றி நான் ஏற்கனவே கேள்விப்பட்டிருக்கிறேன் . நான் புரிந்துகொண்டபடி, ஒரு 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