மாறி தெரிவுநிலை

உள்ளூர் மாறிகள்

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

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

"தெளிவாக, எனக்கு ஒரு உதாரணம் தேவை."

"பிரச்சனை இல்லை. இதோ செல்லுங்கள்:

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     while (true)
     {
       int x = a + b;
       System.out.println(x);
     }
     System.out.println(b);
   }

}

a
a
a
a, b
a, b
a, b
a, b, x
a, b, x
a, b
a, b
a
a

"உள்ளூர் மாறிகளை அணுகுவதற்கான விதிகளை மீண்டும் ஒருமுறை பார்க்கலாம். இதோ ஒரு தொகுதி குறியீடு. அதன் தொடக்கத்தையும் முடிவையும் குறிப்பது எது?"

"சுருள் பிரேஸ்கள்?"

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

"இது வளையத்தின் உடலில் மட்டுமே இருக்கும்."

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

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

"அமிகோ, நீ எனக்குப் பிடித்ததற்கு ஒரு காரணம் இருக்கிறது, இதை உன் மூளையில் உறுதிப்படுத்த இன்னும் ஒரு உதாரணத்தை எடுத்துக் கொள்.

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     System.out.println(b);
   }

   if (a < 20)
   {
     int b = 20;
     System.out.println(b);
   }
}

a
a
a
a, b
a, b
a
a
a
a
a, b
a, b
a

b"இரண்டாவது மாறி அறிவிக்கப்பட்ட குறியீடு தொகுதியில் முதல் bமாறி தெரியவில்லை என்பதால் மட்டுமே பெயரிடப்பட்ட இரண்டாவது உள்ளூர் மாறியை அறிவிக்க முடிந்தது b.

அளவுருக்கள்

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

"ம்ம்ம்... நான் தடுமாறிட்டேன்..."

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

"வேறு வார்த்தைகளில் கூறுவதானால், அவை முறையின் முழு உடலிலும் தெரியும் மற்றும் அங்கே மட்டுமே?"

"ஆம். உதாரணம்:

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     while (true)
     {
       int x = a + b;
       System.out.println(x);
     }
     System.out.println(b);
   }

}

args
args, a
args, a
args, a
args, a, b
args, a, b
args, a, b
args, a, b, x
args, a, b, x
args, a, b
args, a, b
args, a
args, a

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

ஒரு வகுப்பில் உள்ள மாறிகள்

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

"ஒரு வகுப்பின் மாறிகள் (அல்லது புலங்கள்) என்ன ?

அவை ஒரு முறையில் அல்ல, ஒரு வகுப்பில் அறிவிக்கப்படும் மாறிகள்."

"அவர்கள் எதற்காக இருக்கிறார்கள்?"

"தொடக்கத்திற்கு, ஒரு வகுப்பின் எந்த (நிலையற்ற) முறையிலிருந்தும் அவற்றை அணுகலாம். தோராயமாகச் சொன்னால், உதாரண மாறிகள் என்பது ஒரு வகுப்பின் அனைத்து முறைகளாலும் பகிரப்படும் மாறிகள்.

உதாரணமாக:

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

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

   public void remove(int data)
   {
     sum = sum - data;
     count--;
   }
}

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

"இந்த எடுத்துக்காட்டில், எங்களிடம் இரண்டு முறைகள் உள்ளன - add()மற்றும் remove(). இந்த முறை மற்றும் நிகழ்வு மாறிகள் add()அதிகரிக்கிறது , மேலும் முறை மற்றும் மாறிகள் குறைகிறது . இரண்டு முறைகளும் பகிரப்பட்ட நிகழ்வு மாறிகளில் வேலை செய்கின்றன."sumcountremove()sumcount

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

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

நிலையான மாறிகள்

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

"நிலை மாறிகள் பற்றிய தெளிவான புரிதல் எனக்கு இன்னும் இல்லை."

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

"ஒரு நிலையான மாறியை (வகுப்பு மாறி) உருவாக்க, நீங்கள் staticஅதன் அறிவிப்பில் முக்கிய சொல்லை எழுத வேண்டும்.

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

ClassName.variableName

உதாரணமாக:

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

   public void remove(int data)
   {
     Storage.sum = Storage.sum - data;
     Storage.count--;
   }
}

public class Storage
{
   public static int count = 0;
   public static int sum = 0;
}

Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum



Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum

"மேலே உள்ள எடுத்துக்காட்டில், நாங்கள் ஒரு தனி Storageவகுப்பை உருவாக்கி, அதில் countமற்றும் sumமாறிகளை நகர்த்தி, அவற்றை நிலையானதாக அறிவித்தோம் . பொது நிலையான மாறிகளை ஒரு நிரலில் உள்ள எந்த முறையிலிருந்தும் அணுகலாம் (மற்றும் ஒரு முறையிலிருந்து மட்டும் அல்ல)."

"எனக்கு முழுமையாக புரியவில்லை, ஆனால் இது எனக்கு வசதியாகத் தெரிகிறது."

"அப்படித்தான். சில சமயங்களில் இது அவசியம். நிலையான மாறிகள் மற்றும் முறைகள் இல்லாமல் நாம் சிக்கிக்கொள்வோம்."

"நம்பிக்கை, நான் மெதுவாக அதை கண்டுபிடிக்க முடியும்."

"ஆம், நிச்சயமாக நீங்கள் செய்வீர்கள்."