जावा में हमारे पास दो प्रकार के डेटा (या चर) हैं: आदिम और गैर-आदिम (जिन्हें संदर्भ भी कहा जाता है)।

आदिम प्रकार के शाब्दिक मान स्टैक, अस्थायी और अल्पकालिक भंडारण मेमोरी में संग्रहीत होते हैं, जो जावा वर्चुअल मशीन (जेवीएम) द्वारा प्रबंधित होते हैं। [मेमोरी प्रकारों के बारे में यहां और पढ़ें]

आदिम चर को चार समूहों में विभाजित किया गया है:

1. पूर्णांक प्रकार: का उपयोग पूर्णांक (दशमलव भाग के बिना) संग्रहीत करने के लिए किया जाता है। वे हैं: बाइट, शॉर्ट, इंट, लॉन्ग। विभेदन के लिए, संख्या के अंत में लंबे में "L" या "l" अक्षर होता है।

2. फ़्लोटिंग पॉइंट प्रकार: : दशमलव भाग (वास्तविक संख्या) के साथ संख्याओं को संग्रहीत करने के लिए उपयोग किया जाता है। वे हैं: फ्लोट, डबल। भिन्नता के लिए फ्लोट में संख्या के अंत में "F" या "f" अक्षर होता है।

3. वर्ण प्रकार: एकल वर्णों (जैसे अक्षर, अंक या प्रतीक) को संग्रहीत करने के लिए उपयोग किया जाता है: चार। उन्हें दोहरे "" के बजाय एकल उद्धरण '' से आरंभ किया गया है।

4. बूलियन प्रकार: तार्किक मानों को संग्रहीत करने के लिए उपयोग किया जाता है (सही या गलत): बूल

अपने "डिफ़ॉल्ट" मानों के अलावा, प्रत्येक प्रकार द्वारा समर्थित मानों की श्रेणी के लिए नीचे दी गई तालिका देखें:

वैज्ञानिक प्रारूप में, ई एक प्रतिपादक का प्रतिनिधित्व करता है। उदाहरण के लिए, 1.23ई 10, 1.23 x 10^10

डिफ़ॉल्ट मान क्या है? यह वह मान है जिसे वेरिएबल मान लेगा यदि इसे प्रारंभ नहीं किया गया है। हालाँकि, इस मान को मानने के लिए, इसे वैश्विक या स्थिर (अंतिम) होना आवश्यक है।

public final boolean isTrue;

कोड की इस पंक्ति में, वेरिएबल "isTrue" प्रारंभ नहीं किया गया था, लेकिन कंपाइलर कोई त्रुटि प्रस्तुत नहीं करेगा, क्योंकि यह बूलियन वेरिएबल के लिए डिफ़ॉल्ट मान "गलत" पर विचार करेगा।

यहां, एक महत्वपूर्ण चेतावनी: यदि वेरिएबल का दायरा स्थानीय है, यानी, यदि इसे किसी फ़ंक्शन के भीतर घोषित किया गया है, तो हम, प्रोग्रामर, इसे एक मान निर्दिष्ट करने के लिए मजबूर होंगे। अन्यथा, एक संकलन त्रुटि होगी।

public void teste(){
        int i = 2;
        int j;

        if (i 



इस उदाहरण में, भले ही हम जानते हैं कि "2 


  
  
  स्मृति पते


जावा में दूसरे डेटा प्रकार को संदर्भ कहा जाता है। ये वेरिएबल एक संदर्भ को संग्रहीत करते हैं, अर्थात, किसी ऑब्जेक्ट का मेमोरी एड्रेस, इसके मूल्य को सीधे संग्रहीत करने के बजाय, जैसा कि आदिम प्रकारों के साथ होता है। यह भंडारण हीप मेमोरी में होता है।

संदर्भ प्रकार सामान्य रूप से वर्ग, इंटरफ़ेस, एनम और ऑब्जेक्ट हैं। 

यहाँ, एक परिशिष्ट। जिस स्ट्रिंग का हम अपने कोड में व्यापक रूप से उपयोग करते हैं वह एक वर्ग है, न कि कोई आदिम प्रकार। ध्यान दें कि नाम भी बड़े अक्षर में है, जैसा कि जावा में कक्षाओं के लिए नामकरण परंपरा है।

स्ट्रिंग में लंबाई() जैसी विधियां भी हैं, जो इसमें संग्रहीत पाठ का आकार लौटाती है, charAt(int इंडेक्स), जो पाठ में किसी वर्ण का सूचकांक लौटाती है, या सबस्ट्रिंग(int beginIndex, int) लौटाती है एंडइंडेक्स), जो एक स्ट्रिंग का एक टुकड़ा लौटाता है।

लेकिन, यदि आप आदिम डेटा में हेरफेर करना आसान बनाना चाहते हैं, तो जावा इसकी भी अनुमति देता है। इसके लिए, इसमें रैपर क्लास है, जो पहले से ही बुनियादी प्रकारों के साथ काम करने के लिए अंतर्निहित तरीकों की एक श्रृंखला के साथ आता है।

रैपर का नाम मूल रूप से आदिम चर के समान होता है, हालांकि, पहले अक्षर को बड़े अक्षरों में लिखा जाता है: 

• बाइट दर बाइट
• संक्षेप का संक्षिप्त रूप
• पूर्णांक से int
• लंबे से लंबे
• तैरने के लिए तैरना
• दोगुना से दोगुना
• चरित्र से वर्ण
• बूलियन से बूलियन

public class WrapperExample {
    public static void main(String[] args) {
        String numeroStr = "123";
        Integer num1 = Integer.parseInt(numeroStr);
        Integer num2 = 200;

        int resultadoComparacao = Integer.compare(num1, num2);

        if (resultadoComparacao  0) {
            System.out.println(num1   " é maior que "   num2);
        } else {
            System.out.println(num1   " é igual a "   num2);
        }
    }
}

इस उदाहरण कोड में, int रैपर का उपयोग एक स्ट्रिंग को एक संख्या (Integer.parse) में बदलने के लिए किया जाता है और फिर इसकी तुलना किसी अन्य संख्या (Integer.compare) से की जाती है।

हालाँकि, एक स्ट्रिंग में एक विशिष्टता है जो अन्य वर्गों के पास नहीं है। यह अपरिवर्तनीय है।

आइए इस मूल उदाहरण के माध्यम से विचार करें:

public class Main {
  public static void main(String[] args) {

    String text1 = "Hello";
    String text2 = text1;

    System.out.println(text1); //output: Hello
    System.out.println(text2); //output: Hello

    text1 = "Weird";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: Hello

    text2 = "World";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: World

    TestClass test1 = new TestClass("propertyValue");
    TestClass test2 = test1;

    System.out.println(test1.getProperty()); //output: propertyValue
    System.out.println(test2.getProperty()); //output: propertyValue

    test2.setProperty("newValue");

    System.out.println(test1.getProperty()); //output: newValue
    System.out.println(test2.getProperty()); //output: newValue   
  }

}

इस मामले में, ध्यान दें कि, भले ही स्ट्रिंग "टेक्स्ट2" "टेक्स्ट1" को इंगित करती है, "टेक्स्ट2" में परिवर्तन "टेक्स्ट1" में परिवर्तन को प्रतिबिंबित नहीं करते हैं। अब, जब ऑब्जेक्ट "टेस्ट2", जो "टेस्ट1" की ओर इशारा करता है, में एक गुण बदल गया, तो यह परिवर्तन "टेस्ट1" में भी परिलक्षित हुआ।

अरे, लेकिन क्या संदर्भ चर शाब्दिक मानों के बजाय स्मृति पते संग्रहीत नहीं करते हैं? हाँ. वे इसे संग्रहीत करते हैं. क्या होता है कि जावा भाषा डेवलपर्स ने स्ट्रिंग वेरिएबल्स को अपरिवर्तनीय छोड़ने का निर्णय लिया है। इसका मतलब यह है कि एक बार सेट होने के बाद, स्ट्रिंग ऑब्जेक्ट का मान किसी अन्य ऑब्जेक्ट द्वारा अप्रत्यक्ष रूप से नहीं बदला जा सकता है।

उदाहरण में, इसलिए, हम उस ऑब्जेक्ट का मान नहीं बदल रहे हैं जिसे टेक्स्ट1 ने पहले संदर्भित किया था (क्योंकि स्ट्रिंग अपरिवर्तनीय है)। इसके बजाय, हम "अजीब" मान के साथ एक नया स्ट्रिंग ऑब्जेक्ट बना रहे हैं और टेक्स्ट1 को इस नए ऑब्जेक्ट की ओर इंगित कर रहे हैं। जबकि टेक्स्ट2 अभी भी मूल "हैलो" ऑब्जेक्ट को इंगित करेगा और इसीलिए यह "हैलो" मान रखता है।

संक्षेप में, एक स्ट्रिंग को एक नया मान निर्दिष्ट करने से मौजूदा ऑब्जेक्ट का मान संशोधित नहीं होता है, यह सिर्फ एक नई ऑब्जेक्ट का संदर्भ बदलता है।

कस्टम क्लास के ऑब्जेक्ट, जैसे टेस्टक्लास, परिवर्तनशील हैं। टेस्ट1 और टेस्ट2 दोनों संदर्भ एक ही वस्तु की ओर इशारा करते हैं, इसलिए उनमें से एक की स्थिति बदलना दूसरे पर प्रतिबिंबित होता है।