స్టాటిక్ వేరియబుల్స్ మరియు పద్ధతులు

"కొత్త టాపిక్‌కి వెళ్దాం. ఇప్పుడు, నేను స్టాటిక్ వేరియబుల్స్ మరియు మెథడ్స్ గురించి చర్చించాలనుకుంటున్నాను."

"ఎల్లీ, నేను ఇప్పటికే స్టాటిక్ వేరియబుల్స్ మరియు మెథడ్స్ గురించి తెలుసుకున్నాను. అయితే నేను మరిన్ని వివరాలను తెలుసుకోవాలనుకుంటున్నాను."

"మేము క్లాస్‌లో వేరియబుల్స్ డిక్లేర్ చేసినప్పుడు, ఈ వేరియబుల్స్ ఒక్కసారి మాత్రమే సృష్టించబడతాయా లేదా క్లాస్‌లోని ప్రతి ఇన్‌స్టాన్స్ (ఆబ్జెక్ట్) దాని స్వంత కాపీని కలిగి ఉందో లేదో మేము నిర్వచిస్తాము. డిఫాల్ట్‌గా, ప్రతి ఆబ్జెక్ట్ కోసం వేరియబుల్ యొక్క కొత్త కాపీ సృష్టించబడుతుంది. . ఇది ఇలా కనిపిస్తుంది:"

class Cat                        // Class
{
    String name;                 // Variable

    Cat(String name)             // Constructor
    {
        this.name = name;        // Variable initialization
    }
}

Cat cat1 = new Cat("Oscar"); // Create one object whose name variable contains "Oscar"
Cat cat2 = new Cat("Missy"); // Create one object whose name variable contains "Missy"
System.out.println(cat1.name);
System.out.println(cat2.name);

Oscar
Missy

"ఒకే తరగతి (క్యాట్)లో ప్రకటించబడినప్పటికీ, వేరియబుల్స్ cat1.nameమరియు cat2.nameవిభిన్న విలువలను కలిగి ఉంటాయి ఎందుకంటే అవి వేర్వేరు వస్తువులను సూచిస్తాయి."
"ఇది అర్థవంతంగా ఉంది."
"అయితే, క్లాస్ యొక్క ప్రతి ఉదాహరణకి స్టాటిక్ వేరియబుల్ యొక్క ఒక కాపీ మాత్రమే ఉంటుంది మరియు దానిని క్లాస్ పేరును ఉపయోగించి యాక్సెస్ చేయాలి."

class Cat                   // Сlass
{
    String name;            // Instance (non-static) variable
    static int catCount;    // Static variable

    Cat(String name)
    {
        this.name = name;
        Cat.catCount++;   // Increment the static variable by 1
    }
}

System.out.println(Cat.catCount);
Cat cat1 = new Cat("Oscar");

System.out.println(Cat.catCount);
Cat cat2 = new Cat("Missy");

System.out.println(cat1.name);
System.out.println(cat2.name);
System.out.println(Cat.catCount);

0
1
Oscar
Missy
2

"సరే, అది కూడా అర్ధమే."

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

స్టాటిక్ పద్ధతులు నాన్-స్టాటిక్ పద్ధతులు లేదా నాన్-స్టాటిక్ వేరియబుల్స్‌ను పరిష్కరించలేవు!"

"అదెందుకు, ఎల్లీ?"

"ప్రతి ఉదాహరణ వేరియబుల్ ఒక ఆబ్జెక్ట్‌లో ఉంటుంది. మీరు ఆ ఆబ్జెక్ట్‌కు రిఫరెన్స్ కలిగి ఉంటే మాత్రమే దాన్ని యాక్సెస్ చేయవచ్చు. స్టాటిక్ మెథడ్‌కి అలాంటి సూచన అందుబాటులో ఉండదు."

"ఉదాహరణ పద్ధతులకు అలాంటి సూచన ఉందా?"

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

ఆబ్జెక్ట్ రిఫరెన్స్‌కు బదులుగా, శూన్యం స్టాటిక్ పద్ధతులకు పంపబడుతుంది. అందుకే వారు నాన్-స్టాటిక్ వేరియబుల్స్ మరియు మెథడ్స్‌ని పరిష్కరించలేరు. ఈ వేరియబుల్స్ మరియు మెథడ్స్‌తో అనుబంధించబడిన వస్తువుకు వారికి సూచన లేదు."

"సరే, ఎల్లీ, నాకు అర్థమైంది."

"ఈ విధంగా నాన్-స్టాటిక్ పద్ధతులు పని చేస్తాయి:

Cat cat = new Cat();
String name = cat.getName();
cat.setAge(17);
cat.setChildren(cat1, cat2, cat3);

Cat cat = new Cat();
String name = Cat.getName(cat);
Cat.setAge(cat, 17);
Cat.setChildren(cat, cat1, cat2, cat3);

"స్టాటిక్ పద్ధతులు ఎలా పనిచేస్తాయో ఇక్కడ ఉంది:

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount();

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount(null);

"ఒక వేరియబుల్ లేదా మెథడ్ దాని ముందు స్టాటిక్ కీవర్డ్ ఉంటే అది స్థిరంగా ఉంటుంది."

"అవి చాలా తీవ్రంగా పరిమితం అయితే అలాంటి పద్ధతులు ఎందుకు అవసరం?"

"సరే, అలాంటి పద్ధతులు వాటి ప్రయోజనాలను కలిగి ఉన్నాయి."

"మొదట, స్టాటిక్ పద్ధతులు మరియు వేరియబుల్‌లను ఉపయోగించడానికి మేము ఆబ్జెక్ట్ రిఫరెన్స్‌ను పాస్ చేయనవసరం లేదు. "

"రెండవది, కొన్నిసార్లు వేరియబుల్ యొక్క ఒకే ఒక కాపీని కలిగి ఉండటం అవసరం. ఉదాహరణకు, System.out (సిస్టమ్ క్లాస్ యొక్క స్టాటిక్ అవుట్ వేరియబుల్)."

"మూడవది, మీరు వస్తువులను సృష్టించడానికి ముందు కొన్నిసార్లు మీరు ఒక పద్ధతిని కాల్ చేయాలి."

"ఎల్లీ, మీరు దీనికి ఒక ఉదాహరణ చెప్పగలరా?"

" మెయిన్() పద్ధతి స్టాటిక్ అని మీరు ఎందుకు అనుకుంటున్నారు ? ఇది స్టాటిక్ కాబట్టి ప్రోగ్రామర్ ఏదైనా వస్తువులు సృష్టించబడటానికి ముందు క్లాస్‌ని మెమరీలోకి లోడ్ చేసిన వెంటనే కాల్ చేయవచ్చు."