జావా వేరియబుల్స్

ఈ కథనంలో, జావా వేరియబుల్స్ అంటే ఏమిటి మరియు వాటితో ఎలా పని చేయాలో మేము జావా అభ్యాసకులందరికీ వివరించబోతున్నాము.

జావా వేరియబుల్ అంటే ఏమిటి

జావాలోని వేరియబుల్‌ని బాక్స్‌గా భావించవచ్చు. ఈ "బాక్స్" ఒక నిర్దిష్ట పరిమాణాన్ని కలిగి ఉంది: దాని కోసం కేటాయించిన మెమరీ. ఎంత మెమరీ కేటాయించబడుతుంది అనేది వేరియబుల్ రకంపై ఆధారపడి ఉంటుంది, అయితే మేము దీని గురించి కొంచెం తరువాత మాట్లాడబోతున్నాము. అదే సమయంలో, బాక్స్ యొక్క పరిమాణాన్ని దాని సృష్టి తర్వాత మార్చలేము, కానీ కంటెంట్లను మార్చవచ్చు. పెట్టె ఖాళీగా ఉండవచ్చు. మీరు దానిలో కొంత విలువను "చొప్పించవచ్చు", ఆపై సంగ్రహించి, మరికొన్ని విలువలను ఉంచవచ్చు. కాబట్టి, వేరియబుల్ అనేది జావా ప్రోగ్రామ్ అమలు సమయంలో డేటా విలువలను నిల్వ చేసే ఫీల్డ్. ఈ పెట్టె ముఖ్యమైన లక్షణాలను కలిగి ఉంది:

ఇది ఎల్లప్పుడూ ఒక విలువను మాత్రమే కలిగి ఉంటుంది (లేదా ఖాళీగా ఉండవచ్చు, ఈ సందర్భంలో అది డిఫాల్ట్ విలువను కలిగి ఉంటుంది),
ఇది డేటా రకాన్ని కలిగి ఉంటుంది. దాని పరిమాణం డేటా రకంపై ఆధారపడి ఉంటుంది, అలాగే దాని కోసం స్థలం కేటాయించబడిన నిర్దిష్ట మెమరీ ప్రాంతంపై ఆధారపడి ఉంటుంది (అది ఎక్కడ ఉంది).

వేరియబుల్స్ ఎలా ప్రకటించాలి

జావాలో వేరియబుల్స్ డిక్లేర్ చేయడానికి, మీరు దాని రకం మరియు పేరును పేర్కొనాలి. ఇక్కడ మూడు వేరియబుల్స్ డిక్లేర్ చేయడానికి ఒక ఉదాహరణ:


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 విలువను మార్చాము . ఈ ప్రోగ్రామ్‌లో, మేము పంక్తులను ముద్రించాము మరియు మీరు దీన్ని అమలు చేస్తే, మీరు ఈ క్రింది ఫలితాన్ని చూస్తారు:

init init5

జావాలో వేరియబుల్స్ యొక్క డేటా రకాలు: ఆదిమ మరియు నాన్-ప్రైమిటివ్

జావాలోని డేటా రకాల వేరియబుల్స్ రెండు గ్రూపులుగా విభజించబడ్డాయి:

ఆదిమ డేటా రకాలు బైట్ , షార్ట్ , పూర్ణాంక , పొడవు , ఫ్లోట్ , డబుల్ , బూలియన్ మరియు చార్ ఉన్నాయి
స్ట్రింగ్ , అర్రేస్ మరియు క్లాసెస్ వంటి నాన్-ప్రిమిటివ్ డేటా రకాలు

వేరియబుల్స్‌తో పని చేయడానికి ఇక్కడ ఒక ఉదాహరణ:


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));
   }
}

జావాలో వేరియబుల్స్ రకాలు: లోకల్, ఇన్‌స్టాన్స్ మరియు స్టాటిక్

జావాలో మూడు విభిన్న రకాల వేరియబుల్స్ ఉన్నాయి, మేము వాటిని ఈ క్రింది విధంగా జాబితా చేసాము:

స్థానిక వేరియబుల్స్
ఉదాహరణ వేరియబుల్స్
స్టాటిక్ వేరియబుల్స్

స్థానిక వేరియబుల్స్

పద్ధతి యొక్క శరీరం లోపల ప్రకటించబడిన వేరియబుల్‌ను లోకల్ వేరియబుల్ అంటారు. అలాగే, స్థానిక వేరియబుల్స్ కన్స్ట్రక్టర్లు మరియు బ్లాక్స్ లోపల ప్రకటించబడతాయి. మీరు స్థానిక వేరియబుల్‌లను ఆ పద్ధతి, కన్‌స్ట్రక్టర్ లేదా బ్లాక్‌లో మాత్రమే ఉపయోగించగలరు మరియు క్లాస్‌లోని ఇతర పద్ధతులు వేరియబుల్ ఉనికిలో ఉన్నట్లు కూడా తెలియదు. కాబట్టి మెథడ్, కన్స్ట్రక్టర్ లేదా బ్లాక్ ఎంటర్ చేసినప్పుడు లోకల్ వేరియబుల్స్ సృష్టించబడతాయి మరియు మెథడ్, కన్స్ట్రక్టర్ లేదా బ్లాక్ పని చేయనప్పుడు వేరియబుల్ నాశనం అవుతుంది. స్థానిక వేరియబుల్ స్టాటిక్ కీవర్డ్‌తో నిర్వచించబడదు . ఇంకా ఎక్కువ: మీరు స్థానిక వేరియబుల్స్ కోసం యాక్సెస్ మాడిఫైయర్‌లను ఉపయోగించలేరు. ఇక్కడ ఒక ఉదాహరణ:


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);

   }
}

మేము ప్రోగ్రామ్‌ను అమలు చేయడానికి ప్రయత్నిస్తే, అది లోపాన్ని విసురుతుంది:

లోపం:(10, 50) జావా: వేరియబుల్ myBool ప్రారంభించబడి ఉండకపోవచ్చు

ఉదాహరణ వేరియబుల్స్

క్లాస్ లోపల డిక్లేర్డ్ చేయబడిన వేరియబుల్ కానీ ఏదైనా పద్ధతి, కన్స్ట్రక్టర్ లేదా బ్లాక్ యొక్క బాడీ వెలుపల ఉన్న దానిని ఇన్‌స్టాన్స్ వేరియబుల్ అంటారు. కొత్త కీవర్డ్‌ని ఉపయోగించి వస్తువు సృష్టించబడినప్పుడు ఇన్‌స్టాన్స్ వేరియబుల్స్ సృష్టించబడతాయి . వస్తువు నాశనం అయినప్పుడు అది నాశనమవుతుంది. ఇది స్టాటిక్‌గా ప్రకటించబడదు, కానీ మీరు ఉదాహరణకు వేరియబుల్స్ కోసం యాక్సెస్ మాడిఫైయర్‌లను ఉపయోగించవచ్చు. తరగతిలోని అన్ని పద్ధతులు, కన్‌స్ట్రక్టర్‌లు మరియు బ్లాక్‌లకు ఇన్‌స్టాన్స్ వేరియబుల్స్ కనిపిస్తాయి. సాధారణంగా ఇన్‌స్టాన్స్ వేరియబుల్స్ ప్రైవేట్‌గా ఉంటాయి, కానీ మీరు సబ్‌క్లాస్‌ల కోసం దృశ్యమానతను మార్చవచ్చు. స్థానిక వేరియబుల్స్‌కు విరుద్ధంగా ఇన్‌స్టాన్స్ వేరియబుల్స్ డిఫాల్ట్ విలువలను కలిగి ఉంటాయి. అన్ని సంఖ్యల ఆదిమ రకాలకు డిఫాల్ట్ విలువ 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;
}

పై ఉదాహరణలో, మేము ఒక ప్రత్యేక స్టోరేజ్ క్లాస్‌ని సృష్టించాము, దానిలోకి కౌంట్ మరియు సమ్ వేరియబుల్స్‌ని తరలించి, వాటిని స్టాటిక్‌గా ప్రకటించాము. పబ్లిక్ స్టాటిక్ వేరియబుల్స్ ఏదైనా ప్రోగ్రామ్ మెథడ్ నుండి యాక్సెస్ చేయబడతాయి (మరియు ఒక పద్ధతి నుండి మాత్రమే కాదు). మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము