जावा में वस्तुओं की मात्रा

1. गुण: गेटर्स और सेटर्स

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

हो सकता है कि लोग कक्षा दस्तावेज़ीकरण का विस्तार से अध्ययन करने में विफल हों, या शायद यह हर मामले का वर्णन नहीं करता है। नतीजतन, अक्सर ऐसी परिस्थितियां होती हैं जब ऑब्जेक्ट का आंतरिक डेटा "दूषित" हो सकता है, जिससे ऑब्जेक्ट अमान्य हो जाता है।

इन स्थितियों से बचने के लिए, जावा में सभी वर्ग क्षेत्रों को निजी बनाने की प्रथा है । केवल वर्ग के तरीके ही वर्ग के चर को संशोधित कर सकते हैं। अन्य वर्गों की कोई भी विधियाँ सीधे चरों तक नहीं पहुँच सकती हैं।

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

class Person
{
   private String name;

   public Person(String name)
   {
      this.name = name;
   }

   public String getName()
   {
      return name;
   }

   public void setName(String name)
   {
      this.name = name;
   }
}

कोई अन्य वर्ग नाम फ़ील्ड के मान को सीधे परिवर्तित नहीं कर सकता है। अगर किसी को नाम फ़ील्ड का मान प्राप्त करने की आवश्यकता है, तो उसे किसी वस्तु getName() पर विधि को कॉल करना होगा। Personयदि कोई कोड नाम फ़ील्ड के मान को बदलना चाहता है, तो उसे किसी ऑब्जेक्ट setName() पर विधि को कॉल करने की आवश्यकता होगी।Person

विधि getName()को " नाम फ़ील्ड के लिए गेटरsetName() " भी कहा जाता है, और विधि को " नाम फ़ील्ड के लिए सेटर " कहा जाता है।

यह एक बहुत ही सामान्य तरीका है। सभी जावा कोड के 80-90% में, आपको कक्षा में सार्वजनिक चर कभी नहीं दिखाई देंगे। इसके बजाय, उन्हें घोषित किया जाएगा private(या protected), और प्रत्येक चर में सार्वजनिक गेटर्स और सेटर होंगे।

यह दृष्टिकोण कोड को लंबा, लेकिन अधिक विश्वसनीय बनाता है।

एक क्लास वेरिएबल को सीधे एक्सेस करना आपकी कार को दोहरी पीली रेखाओं के माध्यम से मोड़ने जैसा है : यह आसान और तेज़ है, लेकिन अगर हर कोई इसे करता है, तो सभी के लिए चीजें बदतर हो जाती हैं।

मान लें कि आप एक ऐसा वर्ग बनाना चाहते हैं जो एक बिंदु ( x, y) का वर्णन करता हो। यहां बताया गया है कि नौसिखिया प्रोग्रामर इसे कैसे करेगा:

class Point
{
   public int x;
   public int y;
}

यहां बताया गया है कि एक अनुभवी जावा प्रोग्रामर इसे कैसे करेगा:

class Point {
   private int x;
   private int y;

   public Point(int x, int y) {
      this.x = x;
      this.y = y;
   }

   public int getX() {
      return x;
   }

   public void setX(int x) {
      this.x = x;
   }

   public int getY() {
      return y;
   }

   public void setY(int y) {
      this.y = y;
   }
}

क्या कोड लंबा है? निश्चित रूप से।

लेकिन आप गेटर्स और सेटर्स में पैरामीटर सत्यापन जोड़ सकते हैं। उदाहरण के लिए, आप यह सुनिश्चित कर सकते हैं कि xऔर yहमेशा शून्य से अधिक हो (या शून्य से कम नहीं)। उदाहरण:

class Point {
   private int x;
   private int y;

   public Point(int x, int y) {
      this.x = x < 0 ? 0 : x;
      this.y = y < 0 ? 0 : y;
   }

   public int getX() {
      return x;
   }

   public void setX(int x) {
      this.x = x < 0 ?  0 : x;
   }

   public int getY() {
      return y;
   }

   public void setY(int y) {
      this.y = y < 0 ? 0 : y;
   }
}

2. वस्तु जीवनकाल

आप पहले से ही जानते हैं कि newऑपरेटर का उपयोग करके ऑब्जेक्ट बनाए जाते हैं, लेकिन ऑब्जेक्ट कैसे हटाए जाते हैं? वे हमेशा के लिए मौजूद नहीं हैं। उसके लिए पर्याप्त मेमोरी नहीं है।

कई प्रोग्रामिंग भाषाओं में, जैसे C++, deleteवस्तुओं को हटाने के लिए एक विशेष ऑपरेटर होता है। लेकिन यह जावा में कैसे काम करता है?

जावा में, सब कुछ थोड़ा अलग तरीके से व्यवस्थित किया गया है। जावा में कोई डिलीट ऑपरेटर नहीं है। क्या इसका मतलब यह है कि जावा में ऑब्जेक्ट हटाए नहीं गए हैं? नहीं, वे निश्चित रूप से हटा दिए गए हैं। अन्यथा, जावा एप्लिकेशन जल्दी से मेमोरी से बाहर हो जाएंगे, और महीनों तक बिना किसी रुकावट के चलने वाले कार्यक्रमों की कोई बात नहीं होगी।

जावा में, वस्तुओं को हटाना पूरी तरह से स्वचालित है। जावा मशीन ही वस्तुओं को हटाने का काम संभालती है। इस प्रक्रिया को कचरा संग्रहण कहा जाता है, और जो तंत्र कचरा एकत्र करता है उसे कचरा कलेक्टर ( जीसी ) कहा जाता है।

तो जावा मशीन को कैसे पता चलता है कि किसी वस्तु को कब हटाना है?

कचरा संग्राहक सभी वस्तुओं को "पहुंच योग्य" और "पहुंच योग्य" में विभाजित करता है। यदि किसी वस्तु का कम से कम एक संदर्भ है, तो उसे पहुंच योग्य माना जाता है। यदि कोई चर नहीं है जो किसी वस्तु को संदर्भित करता है, तो वस्तु को अगम्य माना जाता है और कचरा घोषित किया जाता है, जिसका अर्थ है कि इसे हटाया जा सकता है।

जावा में, आप किसी मौजूदा वस्तु का संदर्भ नहीं बना सकते हैं - आप केवल उन संदर्भों को निर्दिष्ट कर सकते हैं जो आपके पास पहले से हैं। यदि हम किसी वस्तु के सभी संदर्भों को मिटा देते हैं, तो वह हमेशा के लिए खो जाती है।

परिपत्र संदर्भ

यह तर्क तब तक अच्छा लगता है जब तक कि हम एक साधारण प्रति-उदाहरण पर नहीं आते: मान लीजिए कि हमारे पास दो वस्तुएं हैं जो एक-दूसरे को संदर्भित करती हैं (एक-दूसरे के संदर्भों को संग्रहीत करें)। कोई अन्य वस्तु इन वस्तुओं के संदर्भों को संग्रहीत नहीं करती है।

इन वस्तुओं को कोड से एक्सेस नहीं किया जा सकता है, लेकिन वे अभी भी संदर्भित हैं।

यही कारण है कि कचरा संग्राहक वस्तुओं को "संदर्भित" और "अप्रतिबंधित" के बजाय पहुंच योग्य और अगम्य में विभाजित करता है।

पहुंच योग्य वस्तुएं

सबसे पहले, 100% जीवित वस्तुओं को पहुंच योग्य सूची में जोड़ा जाता है। उदाहरण के लिए, वर्तमान थ्रेड ( Thread.current()) या कंसोल InputStream ( System.in)।

फिर पहुंचने योग्य वस्तुओं की सूची उन वस्तुओं को शामिल करने के लिए विस्तारित होती है जिन्हें पहुंच योग्य वस्तुओं के प्रारंभिक सेट द्वारा संदर्भित किया जाता है। फिर इसे इस बढ़े हुए सेट द्वारा संदर्भित वस्तुओं को शामिल करने के लिए फिर से विस्तारित किया जाता है, और इसी तरह।

इसका अर्थ है कि यदि कुछ वस्तुएँ ऐसी हैं जो केवल एक-दूसरे को संदर्भित करती हैं, लेकिन पहुँच योग्य वस्तुओं से उन तक पहुँचने का कोई रास्ता नहीं है, तो उन वस्तुओं को कचरा माना जाएगा और हटा दिया जाएगा।

3. कचरा संग्रह

स्मृति विखंडन

ऑब्जेक्ट विलोपन से संबंधित एक अन्य महत्वपूर्ण बिंदु स्मृति विखंडन है। यदि आप लगातार वस्तुओं को बनाते और हटाते हैं, तो जल्द ही स्मृति बहुत अधिक विखंडित हो जाएगी: कब्जे वाली स्मृति के क्षेत्रों को रिक्त स्मृति के क्षेत्रों से जोड़ दिया जाएगा।

नतीजतन, हम आसानी से ऐसी स्थिति में पहुंच सकते हैं जहां हम एक बड़ी वस्तु नहीं बना सकते (उदाहरण के लिए, एक लाख तत्वों के साथ एक सरणी), क्योंकि मुक्त स्मृति का एक बड़ा हिस्सा नहीं है। दूसरे शब्दों में, मुक्त स्मृति हो सकती है, यहां तक ​​कि बहुत कुछ, लेकिन मुक्त स्मृति का एक बड़ा सन्निहित ब्लॉक नहीं हो सकता है

मेमोरी ऑप्टिमाइज़ेशन (डीफ़्रेग्मेंटेशन)

जावा मशीन इस समस्या को एक विशिष्ट तरीके से हल करती है। ऐसा कुछ दिखता है:

मेमोरी को दो भागों में बांटा गया है। स्मृति के केवल आधे हिस्से में सभी ऑब्जेक्ट बनाए (और हटाए गए) हैं। जब स्मृति में छिद्रों को साफ करने का समय आता है, तो पहली छमाही में सभी वस्तुओं को दूसरी छमाही में कॉपी किया जाता है। लेकिन उन्हें एक दूसरे के ठीक बगल में कॉपी किया जाता है ताकि कोई छेद न हो।

प्रक्रिया लगभग इस तरह दिखती है:

चरण 1: ऑब्जेक्ट बनाने के बाद

चरण 2: "छेद" की उपस्थिति

चरण 3: "छिद्रों" का उन्मूलन

और इसीलिए आपको वस्तुओं को हटाने की आवश्यकता नहीं है। जावा मशीन बस सभी पहुंच योग्य वस्तुओं को एक नए स्थान पर कॉपी करती है, और स्मृति के पूरे क्षेत्र को मुक्त करती है जहां वस्तुओं को संग्रहीत किया जाता था।