శూన్యం

జావాలో శూన్య అంటే ఏమిటో అర్థం చేసుకోవడానికి , సంఖ్యలతో సారూప్యతను చూద్దాం: సంఖ్య 0 ఏదో లేకపోవడాన్ని సూచిస్తుంది మరియు రిఫరెన్స్ డేటా రకాల విషయానికి వస్తే శూన్య అంటే అదే విషయం. రిఫరెన్స్ రకం ( స్ట్రింగ్ , ఆబ్జెక్ట్ లేదా స్ట్రింగ్‌బిల్డర్ వంటివి ) ఫీల్డ్‌కు స్పష్టంగా విలువను కేటాయించకపోతే, ఆదిమ రకాలతో సారూప్యతతో, అది డిఫాల్ట్ విలువను పొందుతుంది మరియు ఆ విలువ శూన్యం :

public class Solution {

    public static int i;
    public static String s;

    public static void main(String[] args) {
        System.out.println(i);
        System.out.println(s);
    }
}
                    

కానీ మీరు ఇలాంటి శ్రేణిని ప్రకటిస్తే:

String[] strings = new String[12];

12 మూలకాలను కలిగి ఉన్న శ్రేణి సృష్టించబడుతుంది మరియు అవన్నీ శూన్యం :

public class Solution {
    public static void main(String[] args) {
        String[] strings = new String[12];

        for (int i = 0; i < strings.length; i++) {
            System.out.println("Element " + i + ":" + strings[i]);
        }
    }
}
                    

మీరు చూడగలిగినట్లుగా, స్ట్రింగ్‌తో కలిపినప్పుడు, విలువ శూన్యమైన స్ట్రింగ్ " శూన్య " అవుతుంది. మీరు దానిపై 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ని పొందుతాము .