दिलचस्प पोस्ट
कक्षा के लिए सीएसएस 3 एनटी प्रकार प्रतिबंधित मैं एचटीएमएल 5 फॉर्म सत्यापन डिफ़ॉल्ट त्रुटि संदेश कैसे बदल सकता / सकती हूं? कस्टम सर्कल बटन गतिशील रूप से स्रोत के साथ स्क्रिप्ट टैग जोड़ें जिसमें दस्तावेज़ शामिल हो सकता है JFrame बनाम इसे कार्यक्रम के अंदर बनाते हैं किसी विशेष समयक्षेत्र में जावास्क्रिप्ट की तारीख को आरंभ करने के लिए हॉवर पर बोल्ड होने पर इनलाइन तत्वों को बदलते हैं मैं कैसे सी # का उपयोग कर एक REST एपीआई के लिए कॉल कर सकता हूँ? क्या यह AltBeacon के Android Beacon पुस्तकालय के साथ iBeacons का पता लगाने के लिए सही लेआउट है? सादे अंग्रेजी में कॉलबैक की व्याख्या कैसे करें? वे एक समारोह को किसी अन्य समारोह से फोन करने से कैसे अलग हैं? AngularJS का उपयोग कर ASP.NET वेब एपीआई पद्धति से फ़ाइल डाउनलोड करें क्या जावा कास्टिंग ओवरहेड का परिचय है? क्यूं कर? स्थानीय JSON फ़ाइल लोड हो रही है एक क्लासपाथ क्या है? सी में एक सरणी प्रदर्शित करें

विधि पैरामीटर और स्थानीय चर के लिए अंतिम उपयोग करना चाहिए?

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

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

क्या ऐसा कुछ है जो मुझे याद रखने का प्रयास करना चाहिए?

वेब के समाधान से एकत्रित समाधान "विधि पैरामीटर और स्थानीय चर के लिए अंतिम उपयोग करना चाहिए?"

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

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

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

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

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

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

क्या ऐसा कुछ है जो मुझे याद रखने का प्रयास करना चाहिए?

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

"अंतिम" के विकास के समय के फायदे कम से कम रन-टाइम लाभ के रूप में महत्वपूर्ण हैं यह आपके इरादों के बारे में कोड के भावी संपादकों को बताता है

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

एक चर "अंतिम" (और इसे कन्स्ट्रक्टर में निर्दिष्ट) चिह्नित करना निर्भरता इंजेक्शन के साथ उपयोगी है। यह चर के "सहयोगी" प्रकृति को इंगित करता है।

एक विधि "अंतिम" चिह्नित करना अमूर्त वर्गों में उपयोगी है। यह स्पष्ट रूप से बताता है कि विस्तार बिंदु कहाँ हैं।

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

फिर आप उपयोग की स्थिति के करीब घोषित नई चर के साथ पुनः उपयोग किए गए चर को बदलकर कुछ त्रुटियों को ठीक कर सकते हैं। फिर आप पाते हैं कि आप ब्रेकिंग स्कैपिंग में विधि के पूरे भाग को लपेट सकते हैं, और अचानक आप "एक्स्ट्रेक्ट मेथड" से एक आईडीई की दबाने वाली छिपी हैं और आपके राक्षस को अधिक समझ में आता है।

यदि आपकी पद्धति पहले से ही एक अप्रतिबंधित मलबे नहीं है, तो मुझे लगता है कि सामान का फ़ाइनल बनाने में मूल्य हो सकता है ताकि लोगों को इसे बर्बाद कर दिया गया हो। लेकिन अगर यह एक छोटी सी विधि है (देखें: न कि अचयननीय), तो आपको बहुत अधिक शब्दबली जोड़ना होगा। विशेष रूप से, जावा फ़ंक्शन के हस्ताक्षर 80 अक्षर में फिट होने के लिए काफी कठिन होते हैं क्योंकि यह बिना छह और प्रति तर्क को जोड़ता है!

ठीक है, यह आपकी सभी शैली पर निर्भर करता है … यदि आप चर को देखकर पसंद करते हैं, जब आप चर को संशोधित नहीं करेंगे, तो इसका उपयोग करें अगर आप इसे देख नहीं पसंद करते हैं … तो इसे छोड़ दें।

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

मुझे गतिशील भाषाएं पसंद हैं, इसलिए शायद यह कोई आश्चर्यचकित नहीं है कि मैं वर्बोसिस से बचने की कोशिश कर रहा हूं।

तो, मैं कहूंगा कि आप जिस दिशा में झुकाव कर रहे हैं, वह सिर्फ उठाएं और सिर्फ इसके साथ जाएं (जो भी मामला है, लगातार होने की कोशिश करें)


एक तरफ नोट के रूप में, मैंने ऐसे प्रोजेक्ट्स पर काम किया है जो दोनों का उपयोग करते हैं और इस तरह के एक पैटर्न का उपयोग नहीं करते हैं, और मुझे बग या त्रुटियों की मात्रा में कोई अंतर नहीं दिखाई है … मुझे नहीं लगता कि यह एक पैटर्न है जो बेहद ख़राब होगा अपनी बग की गिनती या कुछ भी सुधारें, लेकिन फिर से यह शैली है, और अगर आपको यह आशय व्यक्त करना पसंद है कि आप इसे संशोधित नहीं करेंगे, तो आगे बढ़ो और उसका उपयोग करें

यदि आप किसी ऐसे आवेदन को लिख रहे हैं जिसे किसी व्यक्ति को 1 साल के बाद कोड पढ़ना होगा, तो हाँ, चर पर अंतिम उपयोग करें, जिसे हर समय संशोधित नहीं किया जाना चाहिए। ऐसा करने से, आपका कोड "स्वयं-दस्तावेजी" और अधिक हो जाएगा और आप अन्य डेवलपर्स के लिए मौके को भी कम कर सकते हैं जैसे स्थानीय अस्थायी चर के रूप में स्थानीय स्थिरता का उपयोग करना।

यदि आप कुछ अस्थायी कोड लिख रहे हैं, तो, नहीं, सभी स्थिरों की पहचान करने और उन्हें अंतिम रूप देने के लिए परेशान न करें

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

  public int processSomethingCritical( final int x, final int y ){ // hundreds of lines here // for loop here... int x2 = 0; x++; // bug aarrgg... // hundreds of lines there // if( x == 0 ) { ... } 

बिल्कुल सही दुनिया में ऐसा नहीं होता, लेकिन .. अच्छी तरह से .. कभी-कभी आपको अन्य कोड का समर्थन करना पड़ता है। 🙁

मैं हर समय final उपयोग जावा को अधिक अभिव्यक्ति बनाने के लिए करता हूं जावा की परिस्थितियों को देखें ( if,else,switch ) अभिव्यक्ति आधारित नहीं है जो मुझे हमेशा से नफरत करता है विशेष रूप से यदि आपके कार्यात्मक प्रोग्रामिंग (यानी एमएल, स्काला या लिस्प) के लिए उपयोग किया जाता है।

इस प्रकार आपको शर्तों का प्रयोग करते समय हमेशा (आईएमएचओ) अंतिम चर का उपयोग करने की कोशिश करनी चाहिए।

मैं आपको एक उदाहरण देता हूं:

  final String name; switch(pluginType) { case CANDIDATE_EXPORT: name = "Candidate Stuff"; break; case JOB_POSTING_IMPORT: name = "Blah"; break; default: throw new IllegalStateException(); } 

अब यदि एक अन्य case स्टेटमेंट जोड़ते हैं और name सेट न name तो कंपाइलर असफल हो जायेगा। कंपाइलर भी विफल हो जाएगा यदि आप हर मामले पर नहीं तोड़ते हैं (जो कि आप चर सेट करते हैं)। यह आपको जावा को लिस्प के समान होने के समान बनाने की अनुमति देता है और इसे बना देता है ताकि आपका कोड बड़े पैमाने पर इंडेंटेड नहीं हो (क्योंकि लिक्सिकल स्क्रॉपिंग वैरिएबल)।

और @ रिस्क के रूप में नोट किया गया (लेकिन जाहिरा तौर पर -1 मे) आप कंफ़ाइलर त्रुटि प्राप्त करने के लिए String name final साथ पूर्ववर्ती कर सकते हैं (जिसे मैंने कभी नहीं कहा था) लेकिन आप आसानी से कंपाइलर त्रुटि को सेटिंग नाम से हटा सकते हैं स्विच स्टेटमेंट के बाद जो अभिव्यक्ति अभिव्यक्ति अभिव्यक्ति को दूर कर देता है या break लिए भूल जाने से भूल जाता है, जिसके बाद आप final उपयोग किए बिना किसी त्रुटि के बावजूद (रिक्ति के होने के बावजूद) नहीं कर सकते हैं:

  String name; switch(pluginType) { case CANDIDATE_EXPORT: name = "Candidate Stuff"; //break; whoops forgot break.. //this will cause a compile error for final ;P @Recurse case JOB_POSTING_IMPORT: name = "Blah"; break; } // code, code, code // Below is not possible with final name = "Whoops bug"; 

बग की स्थापना के नाम के कारण (जो भीड़ को भूलने के अलावा एक और बग) मैं अब गलती से ऐसा कर सकता हूं:

  String name; switch(pluginType) { case CANDIDATE_EXPORT: name = "Candidate Stuff"; break; //should have handled all the cases for pluginType } // code, code, code // Below is not possible with final name = "Whoops bug"; 

अंतिम वैरिएबल को एक नाम दिया जाना चाहिए जो कि नाम होना चाहिए। इसी तरह के रूप में एक फ़ंक्शन जिसका रिटर्न वैल्यू होता है, उसे हमेशा नाम (अपवादों को नजरअंदाज) मान लौटा देना चाहिए, नाम स्विच ब्लॉक को नाम से हल करना होगा और इस प्रकार उस स्विच ब्लॉक से बंधेगा जो कोड के रिफ़ैक्टरिंग खंड को आसान बनाता है (यानी Eclipe refactor: extract method) ।

ओसीएमएल में उपर्युक्त:

 type plugin = CandidateExport | JobPostingImport let p = CandidateExport let name = match p with | CandidateExport -> "Candidate Stuff" | JobPostingImport -> "Blah" ;; 

match ... with ... एक समारोह यानी अभिव्यक्ति की तरह मूल्यांकन करता है ध्यान दें कि यह कैसे हमारे स्विच स्टेटमेंट की तरह दिखता है

यहां योजना (रैकेट या चिकन) में एक उदाहरण है:

 (define name (match b ['CandidateExport "Candidate Stuff"] ['JobPostingImport "Blah"])) 

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

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

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

उदाहरण के लिए वैरिएबल, यदि मैं तर्कसंगत रूप से स्थिर हो तो मैं उन्हें अंतिम बना देता।

चर final लिए कई उपयोग हैं यहां महज कुछ हैं

अंतिम स्थिरांक

  public static class CircleToolsBetter { public final static double PI = 3.141; public double getCircleArea(final double radius) { return (Math.pow(radius, 2) * PI); } } 

इसका उपयोग तब आपके कोड के दूसरे भागों के लिए किया जा सकता है, या अन्य वर्गों द्वारा पहुँचा जा सकता है, इस तरह यदि आप कभी भी मान बदल देंगे, तो आपको उन्हें एक-एक करके बदलना नहीं होगा।

अंतिम चर

 public static String someMethod(final String environmentKey) { final String key = "env." + environmentKey; System.out.println("Key is: " + key); return (System.getProperty(key)); } } 

इस वर्ग में, आप एक स्कॉड अंतिम वैरिएबल बनाते हैं जो पैरामीटर पर्यावरण के लिए एक उपसर्ग जोड़ता है। इस मामले में, अंतिम चर केवल निष्पादन क्षेत्र में अंतिम है, जो विधि के प्रत्येक निष्पादन में अलग है। हर बार विधि दर्ज की जाती है, अंतिम रूप से पुनर्निर्माण किया जाता है। जैसे ही यह निर्माण किया जाता है, विधि निष्पादन के दायरे के दौरान इसे बदला नहीं जा सकता। यह आपको पद्धति की अवधि के लिए एक विधि में एक वैरिएबल को ठीक करने की अनुमति देता है। निचे देखो:

 public class FinalVariables { public final static void main(final String[] args) { System.out.println("Note how the key variable is changed."); someMethod("JAVA_HOME"); someMethod("ANT_HOME"); } } 

अंतिम स्थिरांक

 public double equation2Better(final double inputValue) { final double K = 1.414; final double X = 45.0; double result = (((Math.pow(inputValue, 3.0d) * K) + X) * M); double powInputValue = 0; if (result > 360) { powInputValue = X * Math.sin(result); } else { inputValue = K * Math.sin(result); // <= Compiler error } 

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

अंतिम संग्रह

जब हम कलेक्शंस के बारे में बात कर रहे हैं, तो अलग-अलग मामला आपको उन्हें एक अनमोडीएबल के रूप में सेट करना होगा।

  public final static Set VALID_COLORS; static { Set temp = new HashSet( ); temp.add(Color.red); temp.add(Color.orange); temp.add(Color.yellow); temp.add(Color.green); temp.add(Color.blue); temp.add(Color.decode("#4B0082")); // indigo temp.add(Color.decode("#8A2BE2")); // violet VALID_COLORS = Collections.unmodifiableSet(temp); } 

अन्यथा, यदि आप इसे अनगॉडिएबल के रूप में सेट नहीं करते हैं:

 Set colors = Rainbow.VALID_COLORS; colors.add(Color.black); // <= logic error but allowed by compiler 

अंतिम कक्षाएं और अंतिम तरीकों को क्रमशः बढ़ा या ओवरराइट नहीं किया जा सकता है।

संपादित करें: अन्वेषण के संबंध में अंतिम श्रेणी की समस्या का पता:

कक्षा अंतिम बनाने के दो तरीके हैं प्रथम श्रेणी घोषणा में कीवर्ड फ़ाइनल का उपयोग करना है:

 public final class SomeClass { // . . . Class contents } 

कक्षा अंतिम बनाने का दूसरा तरीका अपने सभी कन्स्ट्रक्टरों को निजी के रूप में घोषित करना है:

 public class SomeClass { public final static SOME_INSTANCE = new SomeClass(5); private SomeClass(final int value) { } 

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

 public class Test{ private Test(Class beanClass, Class stopClass, int flags) throws Exception{ // . . . snip . . . } } 

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

तो आपको इसे अंतिम रूप से चिह्नित करना चाहिए जब आप निस्संदेह इसे कन्स्ट्रक्टर निजी बनाकर अंतिम श्रेणी बनाते हैं।

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

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

इसके अलावा, आपने जो कहा है वह सही है

एक चर के लिए final कीवर्ड का उपयोग करें यदि आप उस चर को immutable रूप में बना रहे हैं

चर के रूप में अंतिम घोषित करके, यह डेवलपर्स को अत्यधिक बहु-थ्रेडेड परिवेश में चर के संभावित संशोधन के मुद्दों को बाहर करने के लिए सहायता प्रदान करता है।

जावा 8 रिलीज के साथ, हमारे पास " effectively final variable " नामक एक और अवधारणा है एक गैर-अंतिम चर अंतिम चर के रूप में हो सकता है

लैम्ब्डा अभिव्यक्ति से संदर्भित स्थानीय चर अंतिम या प्रभावी रूप से अंतिम होना चाहिए

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

जावा 7 तक, आप एक अज्ञात वर्ग के अंदर एक गैर-अंतिम स्थानीय चर का उपयोग नहीं कर सकते, लेकिन जावा 8 से आप कर सकते हैं

इस लेख को देखें

एक बहुत ही सरल उत्तर में हमारे पास अंतिम 3 के साथ व्हेरिएबल, फाइनल के साथ तरीकों और अंतिम वर्गों के साथ।

1. चर के साथ अंतिम यदि यूयू एक से अधिक समय इस चर को निर्दिष्ट नहीं कर सकता ..

2. विधियों के साथ अंतिम इस विधि को ओवरराइड नहीं कर सकता ..

3. कक्षाओं के साथ अंतिम आप किसी भी अंतिम वर्ग का विस्तार नहीं कर सकते

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

 final int CM_PER_INCH = 2.54; 

आप चर अंतिम घोषित करेंगे क्योंकि सेंटीमीटर प्रति इंच में परिवर्तन नहीं होता है।

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

 final String helloworld = "Hello World"; helloworld = "A String"; //helloworld still equals "Hello World" 

एक संकलन त्रुटि है जो कुछ ऐसा है:

 local variable is accessed from inner class, must be declared final 

यदि आपकी चर को अंतिम घोषित नहीं किया जा सकता है या यदि आप अंतिम घोषणा नहीं करना चाहते तो यह कोशिश करें:

 final String[] helloworld = new String[1]; helloworld[0] = "Hello World!"; System.out.println(helloworld[0]); helloworld[0] = "A String"; System.out.println(helloworld[0]); 

यह प्रिंट होगा:

 Hello World! A String