பூஜ்ய

ஜாவாவில் பூஜ்யம் என்றால் என்ன என்பதைப் புரிந்து கொள்ள , எண்களுடன் ஒப்புமையைப் பார்ப்போம்: எண் 0 என்பது ஏதாவது இல்லாததைக் குறிக்கிறது, மேலும் குறிப்பு தரவு வகைகளுக்கு வரும்போது பூஜ்யமானது அதையே குறிக்கிறது. ஒரு குறிப்பு வகையின் புலம் ( சரம் , பொருள் , அல்லது StringBuilder போன்றவை ) வெளிப்படையாக மதிப்பை ஒதுக்கவில்லை என்றால், பழமையான வகைகளுடன் ஒப்பிடுவதன் மூலம், அது இயல்புநிலை மதிப்பைப் பெறுகிறது, மேலும் அந்த மதிப்பு பூஜ்யமாக இருக்கும் :

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

நீங்கள் பார்க்க முடியும் என, ஒரு சரத்துடன் இணைக்கப்படும் போது, ​​மதிப்பு null சரம் " பூஜ்ய " ஆகிறது. நீங்கள் அதில் 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 என்பது உண்மை என்று திரும்பும்

முந்தைய பாடங்களில், ஜாவாவில் உள்ள அனைத்தும் ஒரு பொருள் மற்றும் ஒவ்வொரு பொருளுக்கும் ஒரு வகை உள்ளது என்பதைப் பற்றி பேசினோம்.

இந்த விஷயத்தில் பூஜ்யத்தைப் பற்றி நாம் என்ன சொல்ல முடியும் ? null என்பது ஒரு குறிப்பிட்ட வகையின் நேரடிச் சொல்லாகும், மேலும் இந்த வகைக்கு பெயர் இல்லை. இந்த வகைக்கு பெயர் இல்லாததால், இந்த வகையின் மாறியை அறிவிக்கவோ அல்லது அதற்கு அனுப்பவோ இயலாது. எனவே, இந்த பெயரிடப்படாத வகையின் ஒரே பிரதிநிதி பூஜ்யமாகும் . நடைமுறையில், இந்த வகையை நாம் புறக்கணிக்கலாம், மேலும் எந்த குறிப்பு மாறிக்கும் ஒதுக்கக்கூடிய ஒரு சிறப்பு இலக்கியமாக பூஜ்யத்தை நினைக்கலாம் .

நினைவில் கொள்ள வேண்டியவை:

• null என்பது குறிப்பு தரவு வகைகளுக்கான இயல்புநிலை மதிப்பு
• பூஜ்யம் என்றால் "மதிப்பு இல்லை"
• ஒரு பொருளின் மதிப்பு பூஜ்யமாக இருக்கும் எந்த முறையையும் நாம் அழைத்தால் , குறியீடு தொகுக்கப்படும், ஆனால் இயக்க நேரத்தில் நாம் ஒரு NullPointerException ஐப் பெறுவோம் .