दिलचस्प पोस्ट
Chrome में console.log को किसी फ़ाइल में सहेजें UIPageViewController बाउंस को अक्षम करें मैं विंडोज डेवलपमेंट मशीन का इस्तेमाल करके आईफोन के लिए कैसे विकसित कर सकता हूं? लॉक स्टेटमेंट कितना महंगा है? मैं शुद्ध जावास्क्रिप्ट में एक माउसओवर कैसे अनुकरण करता हूं जो सीएसएस ": होवर" को सक्रिय करता है? जावास्क्रिप्ट के साथ ब्राउज़र सीएसएस संपत्ति समर्थन की जाँच करें? सी ++ से एक शब्द फ़ाइल को खोलना और छापना टर्नरी ऑपरेटर का उपयोग करके विधि कॉल यूआरएल से हैश निकालें सी – एक फंक्शन तर्क के रूप में एक 2d सरणी गुजर रहा है? डेटा लोड होने के बाद jqgrid की कॉलम की चौड़ाई कैसे समायोजित करें? स्विंगवॉर्कर का जवाब नहीं है एंड्रॉइड प्रोजेक्ट एक्लिप्स में अन्य प्रोजेक्ट का संदर्भ देने में असमर्थ है मेरे फायरबसे तक अन्य पहुंच को कैसे रोकें? z- अनुक्रमणिका निश्चित स्थिति के साथ काम नहीं कर रहा है

जब जावा में बुलाया अंतिम रूप () विधि है?

मुझे यह जानना होगा कि जब finalize() विधि को JVM में कहा जाता है मैंने एक टेस्ट क्लास बनाया जो एक फाइल में लिखता है जब finalize() विधि इसे ओवरराइड करके कहा जाता है इसे निष्पादित नहीं किया गया है। क्या कोई मुझे बता रहा है कि वह क्यों नहीं चला रहा है?

Solutions Collecting From Web of "जब जावा में बुलाया अंतिम रूप () विधि है?"

सामान्य finalize() से किसी भी सफाई आदि को finalize() पर निर्भर नहीं करना सबसे अच्छा है।

जवाडोक के अनुसार (जो इसे पढ़ने योग्य होगा), यह है:

किसी वस्तु पर कचरा कलेक्टर द्वारा बुलाया जाता है जब कचरा संग्रह निर्धारित करता है कि वस्तु के कोई और संदर्भ नहीं हैं

जैसा कि जोकिम ने बताया, यह एक प्रोग्राम के जीवन में कभी नहीं हो सकता है, यदि वस्तु हमेशा पहुंच योग्य होती है।

इसके अलावा, कचरा कलेक्टर को किसी भी विशिष्ट समय में चलाने की गारंटी नहीं है। सामान्य तौर पर, मैं जो कहने का प्रयास कर रहा हूं वह finalize() संभवतः सामान्य रूप से उपयोग करने का सर्वोत्तम तरीका नहीं है, जब तक कि इसके लिए आपको कुछ विशेष आवश्यकता न हो।

finalize विधि को तब कहा जाता है जब कोई ऑब्जेक्ट कचरा एकत्रित करने वाला होता है। कचरा संग्रहण के लिए पात्र बनने के बाद यह किसी भी समय हो सकता है।

ध्यान दें कि यह पूरी तरह से संभव है कि वस्तु को कचरा एकत्रित नहीं किया जाता (और इस प्रकार finalize से कभी भी नहीं कहा जाता है)। यह तब हो सकता है जब वस्तु कभी जीसी के लिए योग्य नहीं होती (क्योंकि यह JVM के पूरे जीवनकाल तक पहुंच योग्य है) या जब कोई कचरा संग्रह वास्तव में उस समय के बीच चलता है जब ऑब्जेक्ट पात्र हो जाता है और जिस समय JVM चल रहा है (यह अक्सर सरल होता है परीक्षण कार्यक्रम)।

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

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

 protected void finalize() throws Throwable {} 
  • java.lang.Object से हर वर्ग को finalize() विधि
  • इस विधि को कचरा कलेक्टर द्वारा कहा जाता है जब यह वस्तु के अस्तित्व में कोई अधिक संदर्भ निर्धारित नहीं करता है
  • ऑब्जेक्ट को अंतिम रूप देने के तरीके से कोई क्रिया नहीं होती है लेकिन यह किसी भी क्लास द्वारा ओवरराइड हो सकती है
  • सामान्य रूप से इसे गैर-जावा संसाधनों को साफ करने के लिए ओवरराइड किया जाना चाहिए, अर्थात् फ़ाइल को बंद करना
  • अगर ओवरट्रिंग finalize() यह एक प्रोग्रामिंग प्रैक्टिस है जो try-catch-end स्टेटमेंट का उपयोग करता है और हमेशा super.finalize() कॉल करता है super.finalize() । यह एक सुरक्षा उपाय है यह सुनिश्चित करने के लिए कि आप अनजाने में ऑब्जेक्ट कॉलिंग क्लास द्वारा उपयोग किए गए किसी संसाधन को बंद करने की छूट नहीं देते

     protected void finalize() throws Throwable { try { close(); // close open files } finally { super.finalize(); } } 
  • कचरा संग्रह के दौरान finalize() फेंक दिया गया कोई भी अपवाद finalize() रोकता है लेकिन अन्यथा इसकी अनदेखी की जाती है

  • finalize() कभी भी किसी भी ऑब्जेक्ट पर एक बार से अधिक नहीं चलता है

उद्धृत: http://www.janeg.ca/scjp/gc/finalize.html

आप इस लेख को भी देख सकते हैं:

  • वस्तु अंतिम रूप देने और सफाई

जावा finalize() विधि एक नाशक नहीं है और तर्क को संभाल करने के लिए उपयोग नहीं किया जाना चाहिए, जो आपका आवेदन उस पर निर्भर करता है। जावा स्पेक का कहना है कि इसमें कोई गारंटी नहीं है कि आवेदन के livetime के दौरान finalize विधि को बुलाया जाता है।

आप क्या चाहते हैं finally और एक क्लीनअप विधि का एक संयोजन है, जैसा कि:

 MyClass myObj; try { myObj = new MyClass(); // ... } finally { if (null != myObj) { myObj.cleanup(); } } 

प्रभावी जावा, 2 संस्करण पेज 27 की जांच करेंआइटम 7: फाइनलर्स से बचें

फाइनलर्स अप्रत्याशित होते हैं, अक्सर खतरनाक होते हैं, और आमतौर पर अनावश्यक होते हैं। अंतिम रूप में कुछ भी समय-महत्वपूर्ण नहीं करते गंभीर स्थिर राज्य को अद्यतन करने के लिए अंतिम रूप से निर्भर नहीं करते हैं

किसी संसाधन को समाप्त करने के लिए, इसके बजाय कोशिश-अंत में उपयोग करें:

 // try-finally block guarantees execution of termination method Foo foo = new Foo(...); try { // Do what must be done with foo ... } finally { foo.terminate(); // Explicit termination method } 

जब जावा में बुलाया finalize() विधि है?

जीसी को पता लगाता है कि ऑब्जेक्ट अब तक पहुंचने योग्य नहीं है, और ऑब्जेक्ट द्वारा उपयोग किए जाने वाली मेमोरी को वास्तव में पुनः प्राप्त करने से पहले अंतिम विधि को बुलाया जाएगा।

  • यदि कोई वस्तु कभी भी पहुंच नहीं पाई, तो finalize() को कभी भी बुलाया नहीं जाएगा।

  • यदि जीसी नहीं चला तो finalize() को कभी भी फोन नहीं किया जा सकता है (आम तौर पर, जीसी केवल तब चलता है जब JVM फैसला करता है कि पर्याप्त कचरा होने की संभावना है।

  • जीसी द्वारा निर्धारित एक निश्चित ऑब्जेक्ट पहुंच से बाहर नहीं होने से पहले यह एक से अधिक जीसी चक्र ले सकता है। (जावा जीसी सामान्यतया "पीढ़ीदार" कलेक्टर हैं …)

  • एक बार जब जीसी ने पता लगाया कि कोई ऑब्जेक्ट अप्राप्य और अंतिम रूप से उपलब्ध है, तो यह अंतिम रूप से एक कतार पर स्थित है। अंतिम रूप से आम तौर पर सामान्य जीसी के साथ अतुल्यकालिक होता है।

(जेवीएम कल्पना वास्तव में एक जेवीएम को अंतिम रूप से कभी नहीं चलाने की अनुमति देता है … बशर्ते कि वह ऑब्जेक्ट्स द्वारा इस्तेमाल की गई जगह को पुनः प्राप्त नहीं करता है। एक जेवीएम जिसे इस तरीके से लागू किया गया था वह अपंग / बेकार होगा, लेकिन यह व्यवहार "अनुमत" ।)

नतीजा यह है कि निश्चित समय-सीमा में कुछ ऐसी चीजें करने के लिए अंतिम रूप से भरोसा करना चाहिह है जो कि करना है यह "सर्वोत्तम अभ्यास" है, इसका इस्तेमाल उनको बिल्कुल नहीं करना है। जो कुछ भी आप finalize() विधि में करने की कोशिश कर रहे हैं, एक बेहतर (यानी अधिक विश्वसनीय) तरीका होना चाहिए।

अंतिम रूप देने के लिए एकमात्र वैध उपयोग उन वस्तुओं से जुड़े संसाधनों को साफ करना है, जिन्हें एप्लिकेशन कोड द्वारा खो दिया गया है। फिर भी, आपको एप्लिकेशन कोड लिखने की कोशिश करनी चाहिए ताकि वह ऑब्जेक्ट्स को पहली जगह खो न दें। (उदाहरण के लिए, यह सुनिश्चित करने के लिए जावा 7+ प्रयास-के-संसाधनों का उपयोग करें कि close() हमेशा कहा जाता है …)


मैंने एक टेस्ट क्लास बनाया जो एक फाइल में लिखता है जब अंतिम रूप से () विधि इसे ओवरराइड करके कहा जाता है इसे निष्पादित नहीं किया गया है। क्या कोई मुझे बता रहा है कि वह क्यों नहीं चला रहा है?

यह कहना मुश्किल है, लेकिन कुछ संभावनाएं हैं:

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

चूंकि जेवीएम द्वारा अंतिम रूप से () विधि को कॉल करने में अनिश्चितता है (सुनिश्चित नहीं है कि अंतिम रूप से जो ओवरराइज किया गया है) निष्पादित किया जाएगा या नहीं), अध्ययन प्रयोजनों के लिए निरीक्षण करने का बेहतर तरीका क्या होगा जब अंतिम रूप से () कहा जाता है, JVM को System.gc() संग्रह कमान के लिए कॉल करने के लिए बाध्य करें System.gc()

विशेष रूप से, अंतिम रूप से () को तब कहा जाता है जब एक ऑब्जेक्ट अब उपयोग में नहीं है। लेकिन जब हम इसे नए ऑब्जेक्ट बनाकर कॉल करने का प्रयास करते हैं तो उसके कॉल की कोई निश्चितता नहीं होती है। इसलिए निश्चित रूप से हम एक null ऑब्जेक्ट c बनाते हैं, जो स्पष्ट रूप से भविष्य का उपयोग नहीं करता है, इसलिए हम ऑब्जेक्ट c कॉल को अंतिम रूप देते हैं

उदाहरण

 class Car { int maxspeed; Car() { maxspeed = 70; } protected void finalize() { // Originally finalize method does nothing, but here we override finalize() saying it to print some stmt // Calling of finalize is uncertain. Difficult to observe so we force JVM to call it by System.gc(); GarbageCollection System.out.println("Called finalize method in class Car..."); } } class Bike { int maxspeed; Bike() { maxspeed = 50; } protected void finalize() { System.out.println("Called finalize method in class Bike..."); } } class Example { public static void main(String args[]) { Car c = new Car(); c = null; // if c weren`t null JVM wouldn't be certain it's cleared or not, null means has no future use or no longer in use hence clears it Bike b = new Bike(); System.gc(); // should clear c, but not b for (b.maxspeed = 1; b.maxspeed <= 70; b.maxspeed++) { System.out.print("\t" + b.maxspeed); if (b.maxspeed > 50) { System.out.println("Over Speed. Pls slow down."); } } } } 

उत्पादन

  Called finalize method in class Car... 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51Over Speed. Pls slow down. 52Over Speed. Pls slow down. 53Over Speed. Pls slow down. 54Over Speed. Pls slow down. 55Over Speed. Pls slow down. 56Over Speed. Pls slow down. 57Over Speed. Pls slow down. 58Over Speed. Pls slow down. 59Over Speed. Pls slow down. 60Over Speed. Pls slow down. 61Over Speed. Pls slow down. 62Over Speed. Pls slow down. 63Over Speed. Pls slow down. 64Over Speed. Pls slow down. 65Over Speed. Pls slow down. 66Over Speed. Pls slow down. 67Over Speed. Pls slow down. 68Over Speed. Pls slow down. 69Over Speed. Pls slow down. 70Over Speed. Pls slow down. 

नोट – 70 तक छपाई के बाद भी और उसके बाद प्रोग्राम में वस्तु का उपयोग नहीं किया जा रहा है, इसमें अनिश्चितता है कि बी को संचरित किया गया है या नहीं, क्योंकि "क्लास बाइक में अंतिम रूप वाली विधि को बुलाया गया …" मुद्रित नहीं किया गया है।

अंतिम रूप से क्लास निर्माण के लिए गिनती प्रिंट होगा।

 protected void finalize() throws Throwable { System.out.println("Run F" ); if ( checkedOut) System.out.println("Error: Checked out"); System.out.println("Class Create Count: " + classCreate); } 

मुख्य

 while ( true) { Book novel=new Book(true); //System.out.println(novel.checkedOut); //Runtime.getRuntime().runFinalization(); novel.checkIn(); new Book(true); //System.runFinalization(); System.gc(); 

जैसा कि आप देख सकते हैं। निम्नलिखित से पता चला है कि जीसी को पहली बार निष्पादित किया गया था जब कक्षा गिनती 36 है।

 C:\javaCode\firstClass>java TerminationCondition Run F Error: Checked out Class Create Count: 36 Run F Error: Checked out Class Create Count: 48 Run F 

अंतिम रूप से अंतिम तरीके के साथ मल्लयुद्ध (परीक्षण के दौरान कनेक्शन पूल निपटाने के क्रम में), मुझे कहना होगा कि अंतिम रूप में कई चीजें नहीं हैं वास्तविक इंटरैक्शन को ट्रैक करने के लिए कमजोर संदर्भों का उपयोग करने के साथ-साथ VisualVM का उपयोग करते हुए मैंने पाया कि निम्नलिखित बातें एक जावा 8 पर्यावरण (ओरेकल जेडीके, उबंटु 15) में सही हैं:

  • अंतिम रूप को अंतिम रूप से नहीं कहा जाता है, अंतिम रूप से (जीसी भाग) अलग-अलग तरीके से संदर्भ का स्वाभाविक रूप से मालिक है
  • डिफ़ॉल्ट कूड़ा कलेक्टर पूल पहुंच योग्य वस्तुओं नहीं है
  • अंतिम रूप को कार्यान्वित करने के लिए थोक में कहा जाता है कि एक निश्चित चरण है कचरा कलेक्टर संसाधनों को मुक्त कर देता है।
  • कॉलिंग System.gc () अक्सर ऑब्जेक्ट को अधिक बार अंतिम रूप देने के परिणामस्वरूप नहीं होता है, यह फ़ाइनलर के परिणामस्वरूप एक न पहुंचने योग्य ऑब्जेक्ट के बारे में अधिक तेज़ी से जागरूक हो जाता है
  • एक धागा डंप बनाने से लगभग हमेशा हेप डंप या किसी अन्य आंतरिक तंत्र के प्रदर्शन के दौरान उच्च ढेर के ऊपरी भाग के कारण अंतिम रूप से ट्रिगर होता है
  • स्मृति आवश्यकताओं (अधिक मेमोरी को मुक्त) या किसी आंतरिक आंतरिक सीमा से बढ़कर अंतिम रूप देने के लिए चिह्नित ऑब्जेक्ट की सूची द्वारा या तो स्मृति आवश्यकताओं को बाध्य करने के लिए अंतिम रूप से तेजी। इसलिए यदि आपके पास बहुत से ऑब्जेक्ट्स को अंतिम रूप दिया जा रहा है, तो अंतिम रूप से कुछ ही समय के साथ तुलना में अधिक बार और पहले ट्रिगर किया जाएगा
  • ऐसी परिस्थितियों में एक System.gc () ने सीधे अंतिम रूप से ट्रिगर किया लेकिन केवल अगर संदर्भ एक स्थानीय और कम रहने वाला था। यह पीढ़ी संबंधित हो सकता है

अंतिम विचार

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

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

एक ऑब्जेक्ट कचरा संग्रह या जीसी के लिए योग्य हो जाता है, यदि यह किसी भी लाइव थ्रेड्स से नहीं पहुंच योग्य है या किसी अन्य शब्द में कोई स्थिर refrences आप कह सकते हैं कि एक ऑब्जेक्ट कचरा संग्रह के लिए पात्र हो जाता है अगर इसके सभी संदर्भ शून्य हैं चक्रीय निर्भरता को संदर्भ के रूप में गिना नहीं जाता है, इसलिए यदि ऑब्जेक्ट A में ऑब्जेक्ट बी का संदर्भ है और ऑब्जेक्ट बी ऑब्जेक्ट ए के संदर्भ में है और उनके पास कोई अन्य लाइव संदर्भ नहीं है तो ऑब्जेक्ट ए और बी दोनों कूड़ा संग्रह के लिए पात्र होंगे। आम तौर पर एक वस्तु निम्नलिखित मामलों में जावा में कचरा संग्रह के लिए पात्र हो जाती है:

  1. उस ऑब्जेक्ट के सभी संदर्भ स्पष्ट रूप से शून्य पर सेट होते हैं जैसे ऑब्जेक्ट = रिक्त
  2. ऑब्जेक्ट को ब्लॉक के अंदर बनाया जाता है और ब्लॉक से बाहर निकलने पर एक बार संदर्भ का दायरा निकल जाता है।
  3. जनक ऑब्जेक्ट रिक्त करने के लिए सेट है, यदि कोई ऑब्जेक्ट किसी अन्य ऑब्जेक्ट के संदर्भ को संदर्भित करता है और जब आप कंटेनर ऑब्जेक्ट का संदर्भ रिक्त सेट करते हैं, बच्चा या निहित ऑब्जेक्ट स्वचालित रूप से कचरा संग्रहण के लिए योग्य हो जाता है।
  4. अगर किसी ऑब्जेक्ट में केवल WeakHashMap के माध्यम से लाइव संदर्भ होते हैं तो यह कचरा संग्रहण के लिए पात्र होगा।

कक्षा जहां हम अंतिम रूप से विधि को ओवरराइड करते हैं

 public class TestClass { public TestClass() { System.out.println("constructor"); } public void display() { System.out.println("display"); } @Override public void finalize() { System.out.println("destructor"); } } 

विधि को अंतिम रूप देने के लिए कहा जा रहा है

 public class TestGarbageCollection { public static void main(String[] args) { while (true) { TestClass s = new TestClass(); s.display(); System.gc(); } } } 

जब मेमोरी डंप ऑब्जेक्ट्स से अतिभारित होती है, तो जीसी अंतिम रूप से विधि को कॉल करेगी

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

कभी कभी जब इसे नष्ट कर दिया जाता है, तो एक ऑब्जेक्ट को कार्रवाई करना चाहिए। उदाहरण के लिए, यदि किसी ऑब्जेक्ट में कोई गैर-जावा संसाधन होता है जैसे कि फ़ाइल हैंडल या फ़ॉन्ट, तो आप यह सत्यापित कर सकते हैं कि इन संसाधनों को किसी ऑब्जेक्ट को नष्ट करने से पहले रिलीज़ किया गया है। ऐसी परिस्थितियों का प्रबंधन करने के लिए, जावा "अंतिम रूप देने" नामक तंत्र प्रदान करता है इसे अंतिम रूप देकर, आप विशिष्ट क्रियाओं को परिभाषित कर सकते हैं, जब कोई कचरा कलेक्टर से निकाला जा सकता है। एक वर्ग को अंतिम रूप देने के लिए बस अंतिम रूप से () विधि को परिभाषित करें। जावा निष्पादन समय इस पद्धति को कॉल करता है जब भी वह उस वर्ग के ऑब्जेक्ट को हटाना होता है। अंतिम रूप से विधि () के भीतर आप ऑब्जेक्ट को नष्ट करने से पहले क्रियाओं को निर्दिष्ट करते हैं। कचरा कलेक्टर को समय-समय पर वस्तुओं के लिए खोजा जाता है जो संदर्भ के साथ अब किसी भी चलने वाले राज्य या अप्रत्यक्ष रूप से किसी अन्य वस्तु का संदर्भ नहीं लेते हैं। परिसंपत्ति को जारी किए जाने से पहले, जावा रनटाइम ऑब्जेक्ट पर अंतिम रूप () विधि को कॉल करता है अंतिम रूप () विधि में निम्नलिखित सामान्य रूप हैं:

 protected void finalize(){ // This is where the finalization code is entered } 

संरक्षित कीवर्ड के साथ, अपने वर्ग के बाहर कोड द्वारा अंतिम रूप से () तक पहुंच को रोक दिया जाता है। यह समझना महत्वपूर्ण है कि कचरा संग्रह से पहले ही अंतिम रूप से () को बुलाया जाता है। यह नहीं कहा जाता है जब एक ऑब्जेक्ट गुंजाइश छोड़ देता है, उदाहरण के लिए। इसका अर्थ है कि आप कब, कब, अंतिम रूप से () को निष्पादित नहीं किया जा सकता है, पता नहीं कर सकते। नतीजतन, इस कार्यक्रम को ऑब्जेक्ट द्वारा उपयोग किए जाने वाले सिस्टम संसाधनों या अन्य संसाधनों को मुक्त करने के लिए अन्य साधन प्रदान करना चाहिए। आप कार्यक्रम के सामान्य चलने के लिए अंतिम रूप से () पर भरोसा नहीं करना चाहिए।

जावा ऑब्जेक्ट को एक विधि को कार्यान्वित करने की अनुमति देता है जिसे अंतिम नाम () जिसे कॉल किया जा सकता है।

अंतिम तरीके से () विधि को बुलाया जाता है यदि कचरा कलेक्टर ऑब्जेक्ट इकट्ठा करने का प्रयास करता है।

यदि कचरा कलेक्टर नहीं चला है, तो विधि को नहीं कहा जाता है।

यदि कचरा कलेक्टर ऑब्जेक्ट को इकट्ठा करने में विफल रहता है और इसे फिर से चलाने की कोशिश करता है , तो विधि को दूसरी बार बुलाया नहीं जाता है।

व्यवहार में, आप वास्तविक परियोजनाओं में इसका उपयोग करने के लिए अत्यधिक संभावना नहीं हैं

बस इसे ध्यान में रखें कि उसे बुलाया नहीं जा सकता है और यह निश्चित रूप से दो बार नहीं कहा जाएगा। अंतिम रूप () विधि शून्य या एक बार चला सकता है

कचरा कलेक्टर को चलाने की कोई ज़रूरत नहीं होने से पहले, निम्नलिखित कोड में, अंतिम रूप से () पद्धति किसी आउटपुट का उत्पादन नहीं करती है, जब हम इसे चलाने के बाद प्रोग्राम से बाहर निकलते हैं।

स्रोत

बेहतर समझने के लिए इस कार्यक्रम को चलाने की कोशिश करें

 public class FinalizeTest { static { System.out.println(Runtime.getRuntime().freeMemory()); } public void run() { System.out.println("run"); System.out.println(Runtime.getRuntime().freeMemory()); } protected void finalize() throws Throwable { System.out.println("finalize"); while(true) break; } public static void main(String[] args) { for (int i = 0 ; i < 500000 ; i++ ) { new FinalizeTest().run(); } } }