1. స్టాటిక్ వేరియబుల్స్
ఒక తరగతిని మెమరీలోకి లోడ్ చేసినప్పుడు, ఒక స్థిరమైన వస్తువు వెంటనే సృష్టించబడుతుంది. ఈ వస్తువు స్టాటిక్ క్లాస్ వేరియబుల్స్ (స్టాటిక్ క్లాస్ ఫీల్డ్లు) నిల్వ చేస్తుంది. తరగతి యొక్క సాధారణ (నాన్-స్టాటిక్) వస్తువులు సృష్టించబడనప్పటికీ స్థిర వస్తువు ఉనికిలో ఉంటుంది.
మేము తరగతిలో వేరియబుల్లను ప్రకటించినప్పుడు, అవి ఒక్కసారి మాత్రమే సృష్టించబడతాయా లేదా ప్రతి ఆబ్జెక్ట్లో ఈ వేరియబుల్స్ యొక్క విభిన్న సందర్భాలు ఉండాలా అని మేము సూచిస్తాము. డిఫాల్ట్గా, ప్రతి వస్తువు కోసం ప్రతి వేరియబుల్ యొక్క కొత్త కాపీ సృష్టించబడుతుంది.
స్టాటిక్ వేరియబుల్ క్లాస్ యొక్క స్టాటిక్ ఆబ్జెక్ట్కు కట్టుబడి ఉంటుంది మరియు దాని యొక్క ఒకే ఉదాహరణ ఎల్లప్పుడూ ఉంటుంది.
తరగతిలో స్టాటిక్ వేరియబుల్ని సృష్టించడానికి, మీరు static
దాని పేరుకు ముందు కీవర్డ్ని వ్రాయాలి. స్టాటిక్ వేరియబుల్ డిక్లేర్ చేయడానికి సాధారణ ఫార్మాట్:
static Type name = value;
స్టాటిక్ వేరియబుల్ ప్రారంభ విలువను కేటాయించకపోతే, అది డిఫాల్ట్ విలువతో ప్రారంభించబడుతుంది:
టైప్ చేయండి | డిఫాల్ట్ విలువ |
---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
(అదే విషయం
) |
|
|
మరియు ఏదైనా తరగతులు |
|
ఉదాహరణలు:
కోడ్ | గమనిక |
---|---|
|
|
|
|
|
|
|
|
|
తరగతి లోపల, మీరు వాటి పేర్లను ఉపయోగించడం ద్వారా దాని స్టాటిక్ వేరియబుల్లను సూచించవచ్చు. కానీ వాటిని మరొక తరగతి నుండి యాక్సెస్ చేయడానికి, మీరు స్టాటిక్ వేరియబుల్ పేరుకు ముందు తరగతి పేరును వ్రాయాలి.
ClassName.variable
ఉదాహరణ:
వేరియబుల్ | తరగతి | దాని తరగతి వెలుపల వేరియబుల్ని యాక్సెస్ చేయడం |
---|---|---|
|
|
|
|
|
|
|
|
వేరియబుల్ ఉంది private . క్లాస్ బయట కనిపించదు. |
|
|
వేరియబుల్ ఉంది private . క్లాస్ బయట కనిపించదు. |
|
|
వేరియబుల్ ఉంది private . క్లాస్ బయట కనిపించదు. |
2. స్టాటిక్ మరియు నాన్-స్టాటిక్ వేరియబుల్స్ మధ్య వ్యత్యాసం
క్లాస్ యొక్క నాన్-స్టాటిక్ (సాధారణ) వేరియబుల్స్ కీవర్డ్ లేకుండా మాత్రమే స్టాటిక్ వాటిలాగానే ప్రకటించబడతాయి static
.
సాధారణ వేరియబుల్స్ మరియు స్టాటిక్ వేరియబుల్స్ మధ్య తేడా ఏమిటి?
క్లాస్ యొక్క సాధారణ వేరియబుల్స్ క్లాస్ యొక్క వస్తువులకు (తరగతి యొక్క సందర్భాలు) కట్టుబడి ఉంటాయి, అయితే స్టాటిక్ వేరియబుల్స్ క్లాస్ యొక్క స్టాటిక్ ఆబ్జెక్ట్కు కట్టుబడి ఉంటాయి.
ఒక తరగతికి బహుళ సందర్భాలు ఉంటే, వాటిలో ప్రతి దాని స్వంత నాన్-స్టాటిక్ (సాధారణ) వేరియబుల్స్ కాపీని కలిగి ఉంటుంది. క్లాస్ యొక్క స్టాటిక్ వేరియబుల్స్ ఎల్లప్పుడూ దాని స్టాటిక్ ఆబ్జెక్ట్లో నిల్వ చేయబడతాయి మరియు వాటిలో ఒకే ఒక్క ఉదాహరణ మాత్రమే ఉంటుంది.
మీరు తరగతికి చెందిన వస్తువుకు సూచనను కలిగి ఉంటే మాత్రమే మీరు తరగతి యొక్క సాధారణ వేరియబుల్స్ (ఫీల్డ్లు) యాక్సెస్ చేయవచ్చు. మరియు తరగతి లోపల పద్ధతులు, కోర్సు.
ఉదాహరణ:
ఆబ్జెక్ట్ రిఫరెన్స్ని ఉపయోగించి క్లాస్ ఫీల్డ్ని యాక్సెస్ చేయడం |
---|
|
మీరు ఎక్కడి నుండైనా స్టాటిక్ వేరియబుల్స్ను యాక్సెస్ చేయవచ్చు (విజిబిలిటీ మాడిఫైయర్ల కోసం అకౌంటింగ్ తర్వాత): సాధారణ పద్ధతుల నుండి, అదే తరగతికి చెందిన స్టాటిక్ పద్ధతుల నుండి, ఇతర తరగతుల పద్ధతుల నుండి మొదలైనవి.
ఉదాహరణ:
ఆబ్జెక్ట్ రిఫరెన్స్ని ఉపయోగించకుండా క్లాస్ యొక్క స్టాటిక్ ఫీల్డ్ను యాక్సెస్ చేయడం |
---|
|
మెమరీ ఎలా నిర్వహించబడుతుంది:
మనకు 4 ఫీల్డ్లతో క్లాస్ ఉందని అనుకుందాం Person
: రెండు స్టాటిక్ మరియు రెండు కాదు.
public class Person
{
public static int count = 0;
public static int sum = 0;
public int age = 0;
public String name;
}
తరగతిని లోడ్ చేసిన వెంటనే
జావా మెషీన్ తరగతిని లోడ్ చేయడం పూర్తయినప్పుడు Person
, మెమరీ ఇలా కనిపిస్తుంది:
మొదటి వస్తువును సృష్టించిన తర్వాత
మేము ఒక వస్తువును సృష్టిస్తే Person
, అప్పుడు చిత్రం ఇలా అవుతుంది:
రెండు వస్తువులు రెండు వేరియబుల్స్ కలిగి ఉన్నప్పటికీ, ఇవి వేర్వేరు వేరియబుల్స్ అని దయచేసి గమనించండి: సాధారణ వస్తువులు సాధారణ వేరియబుల్స్ కలిగి ఉంటాయి మరియు స్టాటిక్ ఆబ్జెక్ట్ స్టాటిక్ వేరియబుల్స్ కలిగి ఉంటాయి.
మాకు మరిన్ని వస్తువులు కావాలి
మరో రెండు వస్తువులను సృష్టిద్దాం Person
. ఇప్పుడు మెమరీ ఇలా కనిపిస్తుంది:
ప్రతి వస్తువుకు దాని స్వంత వయస్సు మరియు పేరు వేరియబుల్స్ ఉన్నాయని దయచేసి గమనించండి.
3. static
మాడిఫైయర్ని తీసివేయడం మరియు జోడించడం
స్టాటిక్ నుండి సాధారణ వరకు
మనం స్టాటిక్ వేరియబుల్ని తీసుకొని దాని మాడిఫైయర్ని తీసివేసి దానిని సాధారణమైనదిగా మార్చినట్లయితే ఏమి జరుగుతుంది static
? ఉదాహరణకు, static int sum
వేరియబుల్.
సవరించిన కోడ్ ఇలా కనిపిస్తుంది:
public class Person
{
public static int count = 0;
public int sum = 0;
public int age = 0;
public String name;
}
ఇప్పుడు మెమరీ ఇలా కనిపిస్తుంది:
స్టాటిక్ ఆబ్జెక్ట్ నుండి స్టాటిక్ వేరియబుల్ అదృశ్యమైంది మరియు ఇప్పుడు ప్రతి సాధారణ వస్తువు దాని స్వంత sum
వేరియబుల్ కలిగి ఉంది.
సాధారణ నుండి స్టాటిక్ వరకు
మేము దీనికి విరుద్ధంగా చేయవచ్చు: static
మాడిఫైయర్ను తరగతి యొక్క సాధారణ వేరియబుల్స్కు జోడించండి. అవి అన్ని సాధారణ వస్తువుల నుండి అదృశ్యమవుతాయి మరియు స్థిరమైన వస్తువులో కనిపిస్తాయి. మరియు వేరియబుల్స్ను స్టాటిక్గా చేయాలని నిర్ణయించుకున్నాము . age
name
అప్పుడు కోడ్ ఇలా కనిపిస్తుంది:
public class Person
{
public static int count = 0;
public int sum = 0;
public static int age = 0;
public static String name;
}
మరియు ఇప్పుడు మెమరీ ఇలా కనిపిస్తుంది:
GO TO FULL VERSION