జావాలో శూన్య అంటే ఏమిటో అర్థం చేసుకోవడానికి , సంఖ్యలతో సారూప్యతను చూద్దాం: సంఖ్య 0 ఏదో లేకపోవడాన్ని సూచిస్తుంది మరియు రిఫరెన్స్ డేటా రకాల విషయానికి వస్తే శూన్య అంటే అదే విషయం. రిఫరెన్స్ రకం ( స్ట్రింగ్ , ఆబ్జెక్ట్ లేదా స్ట్రింగ్బిల్డర్ వంటివి ) ఫీల్డ్కు స్పష్టంగా విలువను కేటాయించకపోతే, ఆదిమ రకాలతో సారూప్యతతో, అది డిఫాల్ట్ విలువను పొందుతుంది మరియు ఆ విలువ శూన్యం :
కోడ్ | కన్సోల్ అవుట్పుట్ |
---|---|
|
0
శూన్యం |
కానీ మీరు ఇలాంటి శ్రేణిని ప్రకటిస్తే:
String[] strings = new String[12];
12 మూలకాలను కలిగి ఉన్న శ్రేణి సృష్టించబడుతుంది మరియు అవన్నీ శూన్యం :
కోడ్ | కన్సోల్ అవుట్పుట్ |
---|---|
|
మూలకం 0: శూన్య
మూలకం 1: శూన్య మూలకం 2: శూన్య మూలకం 3: శూన్య మూలకం 4: శూన్య మూలకం 5: శూన్య మూలకం 6: శూన్య మూలకం 7: శూన్య మూలకం 8: శూన్య మూలకం 9: శూన్య మూలకం 10: శూన్య మూలకం 11: |
మీరు చూడగలిగినట్లుగా, స్ట్రింగ్తో కలిపినప్పుడు, విలువ శూన్యమైన స్ట్రింగ్ " శూన్య " అవుతుంది. మీరు దానిపై toString() పద్ధతిని కాల్ చేస్తే , ఇలా చెప్పబడింది:
String[] strings = null;
System.out.println(strings.toString());
అప్పుడు మీరు ఒక NullPointerExceptionను పొందుతారు (మేము మినహాయింపులను తర్వాత వివరంగా చర్చిస్తాము). మీరు శూన్య పద్ధతిలో ఏదైనా ఇతర పద్ధతిని కాల్ చేయడానికి ప్రయత్నిస్తే అదే జరుగుతుంది (మినహాయింపు స్టాటిక్ పద్ధతులు, మీరు త్వరలో తెలుసుకుంటారు):
public static void main(String[] args) {
StringBuilder sb = null;
sb.append("test"); // This will compile, but there will be a runtime error
}
null అనేది ఇతర విషయాలతోపాటు, రిజర్వు చేయబడిన కీవర్డ్ ( పబ్లిక్ లేదా స్టాటిక్ వంటివి ) కాబట్టి మీరు null అనే వేరియబుల్, పద్ధతి లేదా తరగతిని సృష్టించలేరు . ఇతరుల మాదిరిగానే, ఈ కీవర్డ్ కేస్-సెన్సిటివ్ (మేము ప్రతిచోటా చిన్న అక్షరాలతో శూన్యం అని వ్రాయడాన్ని మీరు గమనించి ఉండవచ్చు ). అది ఏంటి అంటే:
String firstName = Null; // Compilation error
String secondName = NULL; // Compilation error
String fullName = null; // This will compile
శూన్యంతో మీరు ఇంకా ఏమి చేయగలరో మరియు ఏమి చేయలేరో చూద్దాం :
-
మీరు ఏదైనా సూచనకు శూన్యతను కేటాయించవచ్చు :
StringBuilder sb = null;
-
nullని ఏదైనా సూచన రకానికి ప్రసారం చేయవచ్చు:
String s = (String) null; // This will compile, but doing this doesn't make any sense :)
-
null ఒక ఆదిమ చరరాశికి కేటాయించబడదు:
int i = null; // This won't compile
-
null == మరియు != ఉపయోగించి పోల్చవచ్చు
-
శూన్య == శూన్య రిటర్న్స్ ఒప్పు
మునుపటి పాఠాలలో, జావాలోని ప్రతిదీ ఒక వస్తువు ఎలా ఉంటుందనే దాని గురించి మేము మాట్లాడాము మరియు ప్రతి వస్తువుకు ఒక రకం ఉంటుంది.
ఈ విషయంలో శూన్యత గురించి మనం ఏమి చెప్పగలం ? null అనేది ఒక నిర్దిష్ట రకం యొక్క అక్షరార్థం, మరియు ఈ రకానికి పేరు లేదు. మరియు ఈ రకానికి పేరు లేనందున, ఈ రకమైన వేరియబుల్ను ప్రకటించడం లేదా దానికి ప్రసారం చేయడం అసాధ్యం. కాబట్టి, ఈ పేరులేని రకానికి శూన్య మాత్రమే ప్రతినిధి. ఆచరణలో, మేము ఈ రకాన్ని విస్మరించవచ్చు మరియు ఏదైనా రిఫరెన్స్ వేరియబుల్కు కేటాయించబడే ప్రత్యేక సాహిత్యంగా శూన్యతను పరిగణించవచ్చు.
గుర్తుంచుకోవలసిన విషయాలు:
- null అనేది సూచన డేటా రకాలకు డిఫాల్ట్ విలువ
- శూన్యం అంటే "విలువ లేదు"
- విలువ శూన్యంగా ఉన్న వస్తువుపై మనం ఏదైనా పద్ధతిని కాల్ చేస్తే , కోడ్ కంపైల్ అవుతుంది కానీ రన్టైమ్లో మనం NullPointerExceptionని పొందుతాము .