दिलचस्प पोस्ट
पायथन – मुड़, प्रॉक्सी और संशोधित सामग्री मैं अपने वेब एमवीसी अनुप्रयोग में एक एक्सेस कंट्रोल सूची कैसे लागू करूं? फ्लेक्सबॉक्स कोड सफारी को छोड़कर सभी ब्राउज़रों पर काम कर रहा है। क्यूं कर? जावास्क्रिप्ट का संस्करण का पता लगाएं मैं प्रबंधित बीन के अंदर से संदेश बंडल स्ट्रिंग कैसे प्राप्त करूं? JqGrid में सभी पंक्तियां कैसे दिखाएं? पॉवरहेल में प्रमाणीकृत वेब अनुरोध कैसे करें? एंड्रॉइड: सरणी से प्रोग्रामर स्पिनर बनाएं जब System.gc () कुछ भी करता है कमांड लाइन से एक्लिप्स जावा प्रोजेक्ट बनाएँ MySQL का उपयोग करते हुए एक यादृच्छिक और अद्वितीय 8 वर्ण स्ट्रिंग उत्पन्न करना बनाम क्लास बनाम क्लासेस अलग-अलग तर्कों के साथ एक ही प्रकार के मानचित्र को ऑटोमैपर में प्रोफाइल का उपयोग करना ट्रांसजेन स्पेस बढ़ाएं गिट में एक खास प्रतिबद्धता को वापस लाएं, जो कि दूरस्थ रीपो पर धकेल दिया गया है

जब भी लागू होता है "अंतिम" संशोधक का प्रयोग करके

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

इस पर आपका क्या विचार है और आप क्या अनुसरण करते हैं?

Solutions Collecting From Web of "जब भी लागू होता है "अंतिम" संशोधक का प्रयोग करके"

मुझे लगता है कि यह सब अच्छे कोडिंग शैली के साथ करना है बेशक आप कहीं भी बहुत सारे final संशोधक का उपयोग किए बिना अच्छे, मजबूत कार्यक्रम लिख सकते हैं, लेकिन जब आप इसके बारे में सोचते हैं …

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

सबसे पहले, यह आपके कोड में बहुत से final कीवर्ड देखने के लिए बहुत ही अजीब लग रहा है, लेकिन बहुत जल्द आप शब्द को दिखाना बंद कर देंगे और केवल सोचना होगा, यह-बात-विल-कभी-परिवर्तन-से-इस-बिंदु पर (आप इसे मुझ से ले सकते हैं 😉

मुझे लगता है कि यह अच्छा अभ्यास है मैं हर समय इसका उपयोग नहीं कर रहा हूँ, लेकिन जब मैं कर सकता हूं और इसे final कुछ लेबल करने का समझ हो, तो मैं यह करूँगा।

ग्रस्त रहना उसपर:

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

विचार करें, लेकिन समझदारी से उपयोग करें:

  • अंतिम कक्षाएं – फ़्रेमवर्क / एपीआई डिजाइन ही एकमात्र मामला है, जहां पर मैं इसे देखता हूं।
  • अंतिम तरीकों – मूल रूप से अंतिम कक्षाओं के समान। यदि आप पागल के रूप में टेम्प्लेट विधि पद्धतियों का प्रयोग कर रहे हैं और फ़ार्मल को चिह्नित कर रहे हैं, तो संभवतः आप विरासत पर बहुत अधिक निर्भर हैं और प्रतिनिधिमंडल के लिए पर्याप्त नहीं हैं।

गुदा की भावना को छोड़कर अनदेखा करें:

  • विधि मापदंडों और स्थानीय चर – मैं बहुत ही बड़े पैमाने पर ऐसा करता हूं क्योंकि मैं आलसी हूँ और मुझे लगता है कि यह कोड clutters। मैं पूरी तरह से मानता हूँ कि मार्किंग पैरामीटर और स्थानीय वेरिएबल्स जिन्हें मैं संशोधित नहीं करने वाला हूँ "रैटर" है काश यह डिफ़ॉल्ट था लेकिन यह नहीं है और मुझे लगता है कि फाइनल के साथ-साथ समझने के लिए कोड अधिक कठिन है। अगर मैं किसी और के कोड में हूं, तो मैं उन्हें बाहर खींचने नहीं जा रहा हूं, लेकिन अगर मैं नया कोड लिख रहा हूं तो मैं उन्हें नहीं डालूंगा। एक अपवाद एक ऐसा मामला है जहां आपको कुछ फाइनल के निशान करना है ताकि आप एक्सेस कर सकें यह एक गुमनाम अंदरूनी कक्षा के भीतर से है

इसका उपयोग करने से पहले आपको अंतिम कीवर्ड के पूर्ण उपयोग को समझना होगा यह वैरिएबल्स, फील्ड, मेथड्स और क्लासेस पर लागू हो सकता है और इसमें भिन्नता हो सकती है

मैं अधिक जानकारी के लिए नीचे दिए गए आलेख को देखने की अनुशंसा करता हूं।

अंतिम शब्द अंतिम खोजशब्द पर

final संशोधक, विशेष रूप से चर के लिए, संकलक एक सम्मेलन को लागू करने का एक साधन है जो आम तौर पर समझदार है: सुनिश्चित करें कि एक (स्थानीय या उदाहरण) चर को एक बार ठीक से सौंपा गया है (अब कोई कम नहीं)। एक चर निश्चित रूप से उपयोग किए जाने से पहले सुनिश्चित किया जाता है कि आप एक NullPointerException सामान्य मामलों से बच सकते हैं:

 final FileInputStream in; if(test) in = new FileInputStream("foo.txt"); else System.out.println("test failed"); in.read(); // Compiler error because variable 'in' might be unassigned 

एक से अधिक बार आवंटित किए जाने वाले चर को रोकने से, आप ओवरबोडा स्क्रॉपिंग को हतोत्साहित करते हैं। इसके अलावा:

  String msg = null; for(int i = 0; i < 10; i++) { msg = "We are at position " + i; System.out.println(msg); } msg = null; 

आपको इसका उपयोग करने के लिए प्रोत्साहित किया जाता है:

  for(int i = 0; i < 10; i++) { final String msg = "We are at position " + i; System.out.println(msg); } 

कुछ लिंक:

  • अंतिम कहानी (पुस्तक "हार्डकोर जावा" का मुफ्त अध्याय)
  • कुछ अंतिम पैटर्न
  • निश्चित असाइनमेंट

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

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

हालांकि, मुझे लगता है कि अंतिम चर और तरीकों अंतिम चर संदर्भों के रूप में लगभग उपयोगी नहीं हैं। final घोषणा, जब इन घोषणाओं के साथ प्रयोग किया जाता है तो स्वचालित परीक्षण के लिए रोडब्लॉल्स प्रदान करता है और आपके कोड का उपयोग उन तरीकों से करता है जिन्हें आप कभी भी अनुमानित नहीं कर सकते थे

प्रभावी जावा में एक ऐसा आइटम है जो "अपरिवर्तनीय ऑब्जेक्ट्स का पालन करें" कहता है अंतिम रूप में फ़ील्ड घोषित करने से आपको इसके लिए कुछ छोटे कदम उठाने में मदद मिलती है, लेकिन इस बात से बिल्कुल सही मायने में अपरिवर्तनीय वस्तुएं हैं।

अगर आप जानते हैं कि ऑब्जेक्ट अपरिवर्तनीय हैं, तो बिना किसी सिंक्रनाइज़ेशन के कई थ्रेड्स / क्लाइंट में पढ़ने के लिए उन्हें साझा किया जा सकता है, और प्रोग्राम के चलने के बारे में सोचने में आसान है।

मैं कभी भी ऐसी स्थिति में नहीं था, जहां एक चरम पर अंतिम कीवर्ड होने पर मुझे गलती करने से रोक दिया गया है, इसलिए मुझे लगता है कि यह समय का एक विशाल अपशिष्ट है।

जब तक ऐसा करने का कोई वास्तविक कारण नहीं है (जैसा कि आप चर चरम अंतिम के बारे में एक विशिष्ट बिंदु बनाना चाहते हैं) मैं इसे नहीं करना चाहता हूँ क्योंकि मुझे लगता है कि यह कोड कम पठनीय बना देता है।

अगर, हालांकि, आपको यह नहीं लगता कि यह कोड को पढ़ने के लिए कठिन बनाता है या फिर उसे लिखने के लिए सभी तरीकों से इसके लिए जाएं।

संपादित करें: एक स्पष्टीकरण के रूप में (और नीचे वोटों को जीतने का प्रयास), मैं नहीं कह रहा हूं कि अंतिम रूप में स्थिरांकों को चिह्नित नहीं करना है, मैं कह रहा हूं कि सामान की तरह मत करो:

 public String doSomething() { final String first = someReallyComplicatedExpressionToGetTheString(); final String second = anotherReallyComplicatedExpressionToGetAnother(); return first+second; } 

यह सिर्फ कोड (मेरी राय में) पढ़ने के लिए कठिन बनाता है

यह याद रखना भी जरूरी है कि सभी अंतिम कार्य करता है आपको एक चर को पुन: असाइन करने से रोकता है, यह इसे अपरिवर्तनीय या कुछ ऐसा नहीं बनाती।

अंतिम को हमेशा स्थिरांक के लिए उपयोग किया जाना चाहिए यह भी अल्पकालिक चर के लिए उपयोगी है (एक ही विधि के भीतर) जब चर परिभाषित करने के लिए नियम जटिल हैं।

उदाहरण के लिए:

 final int foo; if (a) foo = 1; else if (b) foo = 2; else if (c) foo = 3; if (d) // Compile error: forgot the 'else' foo = 4; else foo = -1; 

मैं ऑब्जेक्ट एट्रिब्यूट्स के लिए हर बार final उपयोग करता हूं।

ऑब्जेक्ट एट्रिब्यूट्स पर उपयोग किए जाने पर final कुंजीशब्द के दृश्यता शब्दार्थ हैं। असल में, अंतिम ऑब्जेक्ट विशेषता का मान होता है- कन्स्ट्रक्टर वापसी से पहले इसका मतलब यह है कि जब तक आप this संदर्भ को निर्माता से बच नहीं देते हैं और आप अपने सभी विशेषताओं के लिए final उपयोग करते हैं, तो आपका ऑब्जेक्ट (जावा 5 सिमेंटिक के अंतर्गत) सही तरीके से निर्मित होने के लिए अनुचित है, और चूंकि यह भी अपरिवर्तनीय है सुरक्षित रूप से अन्य थ्रेड्स में प्रकाशित

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

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

मुझे लगता है कि मुझे अपनी कक्षाओं में अधिकतर फाइनल करना चाहिए, लेकिन मुझे अभी तक हब में नहीं मिला है।

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

अंतिम रूप से स्पष्ट रूप से स्थिरांक पर इस्तेमाल किया जाना चाहिए, और अपरिवर्तनीयता को लागू करने के लिए, लेकिन तरीकों पर एक और महत्वपूर्ण उपयोग होता है

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

यह कठोर लग सकता है, लेकिन यह समझ में आता है यदि आप दूसरों के इस्तेमाल के लिए एक कक्षा पुस्तकालय लिख रहे हैं तो आप उन चीजों से इनहेरिट करना नहीं चाहते हैं जो इसके लिए डिज़ाइन नहीं किए गए थे – आप वापस संगतता के लिए कक्षा के एक विशेष कार्यान्वयन में अपने आप को लॉक कर रहे होंगे। यदि आप एक टीम में कोडिंग कर रहे हैं, तो टीम के दूसरे सदस्य को अंतिम रूप से निकालने से रोकने के लिए कुछ भी नहीं है यदि उन्हें वास्तव में करना है लेकिन कीवर्ड उनसे ऐसा सोचते हैं कि वे क्या कर रहे हैं, और उन्हें चेतावनी दी है कि जिन वर्गों से इन्हें विरासत में लिया गया है, उनके लिए डिज़ाइन नहीं किया गया था, इसलिए उन्हें सावधान रहना चाहिए।

एक और चेतावनी यह है कि कई लोग अंतिम को भ्रमित करने के लिए कहते हैं कि उदाहरण चर की सामग्री को बदल नहीं सकता है, इसके बजाय संदर्भ बदल नहीं सकता है।

अंतिम कीवर्ड का उपयोग करने के विरुद्ध सबसे बड़ी तर्क की तरह लगता है कि "यह अनावश्यक है", और यह "कचरा अंतरिक्ष" है

अगर हम "अंतिम" के बहुत से लाभों को स्वीकार करते हैं, जैसा कि यहां कई महान पोस्ट्स की ओर इशारा किया है, तो स्वीकार करते हुए कि यह अधिक टाइपिंग और स्थान लेता है, मैं तर्क दूंगा कि जावा में "अंतिम" को डिफ़ॉल्ट रूप से चर किया जाना चाहिए, और इन चीजों को " अस्थिर "अगर सांकेतिक शब्दों में कहलाए इसे होना चाहता है

प्रत्येक पद्धति में प्रत्येक पैरामीटर के लिए final टाइप करना चुनना कोडर्स और कोड पाठकों दोनों के लिए इतना चिड़चिड़ा पैदा करेगा।

एक बार जब जलन स्कैला को उचित स्विच से परे जाती है, जहां तर्क डिफ़ॉल्ट रूप से अंतिम होता है।

या, आप हमेशा कोड स्टाइलिंग टूल का उपयोग कर सकते हैं जो आपके लिए स्वचालित रूप से करेंगे। सभी आईडीई ने उन्हें लागू किया है या प्लगइन्स के रूप में।

अंतिम जब जावा में चर के साथ उपयोग किया जाता है तो C ++ में स्थिर के लिए विकल्प प्रदान करता है तो जब एक चर के लिए अंतिम और स्थिर का उपयोग किया जाता है तो यह अपरिवर्तनीय हो जाता है एक ही समय में माइग्रेटेड सी ++ प्रोग्रामर बहुत खुश हैं 😉

जब संदर्भ चर के साथ प्रयोग किया जाता है, तो यह ऑब्जेक्ट को पुनः संदर्भ देने की अनुमति नहीं देता है, हालांकि ऑब्जेक्ट को हेरफेर किया जा सकता है।

जब एक विधि के साथ अंतिम उपयोग किया जाता है, तो यह उपवर्गों द्वारा विधि को अधिक से ग्रस्त होने की अनुमति नहीं देता है

एक बार उपयोग बहुत स्पष्ट है, इसे देखभाल के साथ इस्तेमाल किया जाना चाहिए। यह मुख्य रूप से डिजाइन पर निर्भर करता है क्योंकि इस पद्धति पर अंतिम उपयोग से बहुरूपता नहीं होती है।

किसी को केवल चर के लिए उपयोग करना चाहिए, जब आप यह सुनिश्चित कर लें कि चर का मूल्य / कभी भी बदला नहीं जाना चाहिए यह भी सुनिश्चित करें कि आप SUN द्वारा प्रोत्साहित कोडिंग सम्मेलन का पालन करें। उदाहरण के लिए: अंतिम अंतराल COLOR_RED = 1; (अंडरस्कोर से अलग ऊपरी मामले)

एक संदर्भ चर के साथ, इसका उपयोग केवल तभी करें जब हमें किसी विशिष्ट ऑब्जेक्ट के लिए अपरिवर्तनीय संदर्भ चाहिए।

पठनीयता के भाग के संबंध में, सामने आओ कि अंतिम संशोधक का उपयोग करते समय टिप्पणी एक बहुत महत्वपूर्ण भूमिका निभाती है।

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

बहुत ही समान सदस्य चर पर भी लागू होता है, क्योंकि वे स्थिरों के मामले को छोड़कर थोड़ा लाभ देते हैं।

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

लेकिन हे, यह सिर्फ मेरी राय है 🙂

मैंने सभी क्षेत्रों और विशेषताओं पर अंतिम जोड़ने के लिए ग्रहण की स्थापना की है जिन्हें संशोधित नहीं किया गया है। यह एक्लिप्स "बचत कार्यों" का उपयोग करके महान काम करता है जो फाइल को सहेजते समय इन अंतिम संशोधक (अन्य बातों के अलावा) जोड़ता है।

अत्यधिक सिफारिशित।

एक्लिप्स सेव एक्शन के मेरे ब्लॉग पोस्ट को देखें

मैं विधियों या कक्षाओं पर अंतिम रूप से अंतिम रूप से उपयोग नहीं करता हूं क्योंकि मैं लोगों को उन्हें ओवरराइड करने की इजाजत देता हूं।

अन्यथा, मैं केवल अंत में उपयोग करता हूं अगर यह एक public/private static final type SOME_CONSTANT;

यहां तक ​​कि स्थानीय चर के लिए, यह ज्ञात है कि इसे अंतिम घोषित किया जाता है इसका मतलब है कि संदर्भ में बाद में बदला जाने के बारे में मुझे चिंता करने की ज़रूरत नहीं है। इसका मतलब यह है कि जब डीबग करना और मुझे बाद में उस चर को देखते हैं, मुझे विश्वास है कि यह उसी ऑब्जेक्ट का संदर्भ दे रहा है यह एक कम बात है जब मुझे बग की तलाश में चिंता करने की ज़रूरत है एक बोनस यह है कि अगर 99% चर को अंतिम घोषित किया जाता है, तो कुछ चर जो वास्तव में चर रहे हैं बेहतर खड़े हैं साथ ही, फाइनल में कंपाइलर को और अधिक संभव बेवकूफ गलतियाँ मिलती हैं जो अन्यथा बिना किसी का ध्यान रख सकते हैं।

तर्क के लिए मुझे लगता है कि उन्हें जरूरत नहीं है। अधिकांशले वे सिर्फ पढ़ने योग्यता को नुकसान पहुँचाते हैं एक तर्क चरखी पुनरावृत्ति करना इतना बेवकूफ़ बेवकूफ़ है कि मुझे पूरा भरोसा होना चाहिए कि उन्हें वैसे भी स्थिरांक माना जा सकता है

तथ्य यह है कि ग्रहण लाल अंतिम लाल बनाता है यह कोड में चर घोषणाओं को स्थानापन्न करना आसान बनाता है जो मुझे लगता है कि अधिकांश समय में रीडबिलिटी में सुधार होता है।

मैं इस नियम को लागू करने की कोशिश करता हूं कि किसी भी और सभी चर को अंतिम होना चाहिए, ऐसा नहीं है कि यह एक वैध वैध कारण नहीं है। "यह चर क्या है" का जवाब देना इतना आसान है? सवाल है कि आपको सिर्फ असंबद्धता प्राप्त करने और आश्वस्त होना चाहिए कि वह यही है।

वास्तव में मैं न घबराता हूं, नॉन-फाइनल चर के आस-पास, अब एक दिन। यह एक धागे में फांसी चाकू के बीच अंतर की तरह है, जो आपके सिर को ध्वस्त करता है, या बस इसे आप रसोई के दराज वाले हैं …

एक अंतिम चर सिर्फ योग्य मूल्यों के लिए एक अच्छा तरीका है

एक गैर अंतिम चर कुछ बग-प्रवण एल्गोरिथ्म के भाग के लिए बाध्य है।

एक अच्छी सुविधा यह है कि जब कोई एल्गोरिथ्म के लिए प्रश्न के बाहर एक चर का उपयोग करने का विकल्प होता है, तो अधिकांश समय sollution इसके बजाय एक विधि लिखना है, जो आमतौर पर कोड को सुधारता है

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

यह कहा जा रहा है कि अगर मैं कोई भाषा तैयार करूँगा, तो मैं हर वैरिएबल फ़ाइनल कर दूँगा जब तक कि कुछ अन्य कीवर्ड द्वारा संशोधित नहीं किया जाएगा।

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

मैं भी Collections.unmodifiable का उपयोग करें … जब मैं करने की आवश्यकता unmodifiable सूचियों बनाने के लिए

ईवेंट श्रोताओं के लिए अनाम स्थानीय कक्षाओं का उपयोग करना और ऐसा जावा में एक सामान्य पैटर्न है अंतिम कीवर्ड का सबसे आम उपयोग यह सुनिश्चित करना है कि दायरे में वेरिएबल भी श्रोता के लिए सुलभ हैं

हालांकि, यदि आप पाते हैं कि आपको अपने कोड में कई अंतिम बयानों को लगाया जाना आवश्यक है यह एक अच्छा संकेत हो सकता है कि आप कुछ गलत कर रहे हैं

उपरोक्त लेख इस उदाहरण को देता है:

 public void doSomething(int i, int j) { final int n = i + j; // must be declared final Comparator comp = new Comparator() { public int compare(Object left, Object right) { return n; // return copy of a local variable } }; } 

मैं इसका इस्तेमाल विधियों के अंदर और बाहर स्थिरांक के लिए करता हूं।

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

जहां तक ​​कक्षाएं हैं, केवल कुछ बुनियादी ढांचे कक्षाओं के लिए, मैंने अंतिम कक्षा का इस्तेमाल किया है।

IntelliJ IDEA आपको चेतावनी देता है कि फ़ंक्शन पैरामीटर के अंदर फ़ंक्शन के अंदर लिखा जाता है। इसलिए, मैंने फ़ंक्शन तर्कों के लिए अंतिम उपयोग करना बंद कर दिया है I मैं उन्हें जावा रनटाइम लाइब्रेरी के अंदर भी नहीं देखता हूं।

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

क्लास फाइनल को चिह्नित करने से रनटाइम के बजाय संकलन समय पर कुछ विधि बाइंडिंग भी हो सकते हैं। नीचे "v2.foo ()" पर विचार करें – संकलक को पता है कि बी में कोई उपवर्ग नहीं हो सकता है, इसलिए foo () ओवरराइड नहीं किया जा सकता है ताकि कॉल करने के कार्यान्वयन को समय संकलन में जाना जाता है। यदि वर्ग बी को अंतिम रूप में चिह्नित नहीं किया गया है, तो यह संभव है कि v2 का वास्तविक प्रकार कुछ वर्ग है जो बी का विस्तार करता है और फ़ू (ओवरव्यू) करता है।

 class A { void foo() { //do something } } final class B extends A { void foo() { } } class Test { public void t(A v1, B v2) { v1.foo(); v2.foo(); } }