ஜாவா மாறிகள்

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

ஜாவா மாறி என்றால் என்ன

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

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

மாறிகளை எவ்வாறு அறிவிப்பது

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

int myInt;
String s;
Object variableName;

இங்கே int , String , Object ஆகியவை தரவு வகை மற்றும் myInt , s , variableName ஆகியவை மாறி பெயர்கள். நிரலின் தேவைகளின் அடிப்படையில் தரவு வகை தேர்ந்தெடுக்கப்பட வேண்டும், மேலும் ஒரு பெயரைத் தேர்ந்தெடுப்பது நல்லது, அது எதைப் பற்றியது என்பது தெளிவாகிறது. நிச்சயமாக, ஆரம்பநிலையாளர்களுக்கு இது அவ்வளவு கண்டிப்பானது அல்ல, ஆனால் பெரிய திட்டங்களில், 's' போன்ற மாறி பெயர்கள் குறியீட்டின் வாசிப்புத்திறனை பாதிக்கலாம். எனவே மாறிகள் எதற்காக என்பதைத் தெளிவுபடுத்தும் வகையில் ஆரம்பத்திலேயே பெயரிடப் பழகிக் கொள்வது நல்லது. காரணத்திற்குள், நிச்சயமாக.

மாறிகளை எவ்வாறு துவக்குவது

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

public class VariableTest {
    public static void main(String[] args) {
        int myInt = 5;
        String s;
        s = "init";
        System.out.println(s);
        s = s+5;
        System.out.println(s);
    }
}

இங்கே நாம் myInt மாறியை ஒரு வரியில் அறிவித்து துவக்கி, அதற்கு உடனடியாக நினைவகத்தை (ஒவ்வொரு முழு எண்ணுக்கும் 32 பிட்கள்) ஒதுக்கி, அதற்கு ஒரு பெயரைக் கொடுத்து, பின்னர் ஒதுக்கப்பட்ட நினைவகத்தில் மதிப்பு 5 ஐ வைத்தோம் . s என்ற சரத்திற்கு நினைவக இடத்தை ஒதுக்குகிறோம் என்று அறிவித்தோம் , ஏற்கனவே ஒரு தனி கட்டளை "init" மதிப்பை அதில் வைத்தது. அதன் பிறகு, சரத்தை அச்சிட்டு, s என்ற மாறியின் மதிப்பை மாற்றினோம் . இந்த நிரலில், நாங்கள் வரிகளை அச்சிட்டோம், நீங்கள் அதை இயக்கினால், பின்வரும் முடிவைக் காண்பீர்கள்:

ஜாவாவில் உள்ள மாறிகளின் தரவு வகைகள்: பழமையான மற்றும் பழமையானவை அல்ல

ஜாவாவில் உள்ள மாறிகளின் தரவு வகைகள் இரண்டு குழுக்களாக பிரிக்கப்பட்டுள்ளன:

• பழமையான தரவு வகைகளில் பைட் , ஷார்ட் , இன்ட் , லாங் , ஃப்ளோட் , டபுள் , பூலியன் மற்றும் சார் ஆகியவை அடங்கும்
• சரம் , அணிவரிசைகள் மற்றும் வகுப்புகள் போன்ற பழமையான தரவு வகைகள்

மாறிகளுடன் வேலை செய்வதற்கான ஒரு எடுத்துக்காட்டு இங்கே:

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point number
       char myLetter = 'a';         // character
       boolean myBool = true;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);
      
   }
}

int , char , boolean , மற்றும் float ஆகியவை பழமையானவை. சரம் பழமையானது அல்ல. myStudent மாறி பற்றி என்ன ? இது பயனரால் உருவாக்கப்பட்ட மாணவர் வகுப்பின் பொருளாகும் . இது பழமையான மாறிகள் கொண்ட வேலையை விளக்குவதற்காக உருவாக்கப்பட்டது. இந்த நிரலாக்க மொழியில் உள்ள அனைத்தும் ஒரு பொருளாக இருப்பதால், ஜாவாவில் அவர்கள் பெரும்பான்மையாக உள்ளனர். புரிந்து கொள்ள, மாணவர் வகுப்பின் குறியீடு இங்கே :

import java.util.Date;

public class Student {
   String surname;
   String name;
   String secondName;
   Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

   @Override
   public int hashCode(){
       //TODO: check for nulls
       //return surname.hashCode() ^ name.hashCode() ^ secondName.hashCode() ^ (birthday.hashCode());
       return (surname + name + secondName + birthday).hashCode();
   }
   @Override
   public boolean equals(Object other_) {
       Student other = (Student)other_;
       return (surname == null || surname.equals(other.surname) )
               && (name == null || name.equals(other.name))
               && (secondName == null || secondName.equals(other.secondName))
               && (birthday == null || birthday.equals(other.birthday));
   }
}

ஜாவாவில் மாறிகளின் வகைகள்: உள்ளூர், நிகழ்வு மற்றும் நிலையானது

ஜாவாவில் மூன்று வெவ்வேறு வகையான மாறிகள் உள்ளன, அவற்றை பின்வருமாறு பட்டியலிட்டுள்ளோம்:

1. உள்ளூர் மாறிகள்
2. நிகழ்வு மாறிகள்
3. நிலையான மாறிகள்

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

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

public class VariableTest {
   public static void main(String[] args) {
       System.out.println(myMethod("C plus "));
   }
           private static String myMethod(String myString) {
       String myOtherString = "plus";
       return myString + myOtherString;
   }
}

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

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point 
       char myLetter = 'a';         // character
       boolean myBool;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

நாங்கள் நிரலை இயக்க முயற்சித்தால், அது ஒரு பிழையை ஏற்படுத்தும்:

நிகழ்வு மாறிகள்

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

//instance variable example
public class Employee {

   // here we have a public instance variable. It is visible for this class and child classes
   public String name;

   //this instance variable is private so it’s visible for the Employee class only. You can use setters and getters to get it
   private double salary;

   public Employee (String empName) {
       name = empName;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public double getSalary() {
       return salary;
   }

   public void setSalary(double employeeSalary) {
       salary = employeeSalary;
   }

   public static void main(String args[]) {
       Employee employee = new Employee("Johnny");
       employee.setSalary(1500);
       System.out.println("name = " + employee.getName());
       System.out.println("salary = " + employee.getSalary());
   }
}

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

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

public class Box
{
   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;
}

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