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

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

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

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

எளிமைக்காக, ஒரு உதாரணத்தைக் கருத்தில் கொள்வோம்:

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.

2. அளவுருக்கள்

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

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

உதாரணமாக:

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இது ஒரு மாறி, அதன் வகை சரங்களின் வரிசை. எல்லா அளவுருக்களையும் போலவே, இது முறையின் உடலில் எல்லா இடங்களிலும் கிடைக்கிறது. நாங்கள் பொதுவாக எங்கள் உதாரணங்களில் அதை புறக்கணிக்கிறோம் என்று கூறினார்.

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

ஒரு வகுப்பில் முறைகள் மற்றும் மாறிகள் இருக்கலாம் என்பதை நிலை 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

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

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

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

நிலை 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 மாறிகளை நகர்த்தி, அவற்றை நிலையானதாக அறிவித்தோம் . பொது நிலையான மாறிகளை ஒரு நிரலில் உள்ள எந்த முறையிலிருந்தும் அணுகலாம் (மற்றும் ஒரு முறையிலிருந்து மட்டும் அல்ல).