दिलचस्प पोस्ट
एकल बैंड में कई पंक्तियां होने के दौरान डेटा अतिप्रवाह के साथ एक पंक्ति बढ़ाएं AngularJS के साथ गहरे मर्ज ऑब्जेक्ट HTML5 कैनवास तत्व को अपनी सामग्री के साथ क्लोन करने का कोई तरीका? मैं स्वयं को हस्ताक्षर किए प्रमाण पत्र कैसे स्वीकार कर सकता हूं? एंड्रॉइड में प्रगति बार की प्रगति रंग कैसे बदल सकता है सोप-त्रुटि: पार्सिंग डब्ल्यूएसडीएल: से लोड नहीं किया जा सका – लेकिन WAMP पर काम करता है क्यों सी # पढ़ने योग्य स्थानीय चर अस्वीकृत करता है? सीएसएस में पीएनजी छवि के लिए ड्रॉप छाया IIS7.5 में एएसपी क्लासिक कैसे सक्षम करें I क्या HTTP बुनियादी प्रमाणीकरण के लिए मुझे एन्कोडिंग का उपयोग करना चाहिए? Linq का उपयोग कर रिकॉर्ड्स के लिए क्वेरी एक्सएमएल फाइल एआरसी + NSZombieEnabled का उपयोग करते समय ऑब्जेक्ट क्यों नहीं dealloc'ed है मैं इसे कैसे कस्टम ऑब्जेक्ट के साथ एक NSMutableArray सॉर्ट कर सकता हूँ? सी # में, मैं स्टाइल ट्रेस को खोए बिना इनरएक्सेशन को कैसे पुनः ला सकता हूं? किसी फ़ंक्शन पर एक प्रगति बार कैसे कनेक्ट करें?

स्थिर चर को बुरा क्यों माना जाता है?

मैं एक जावा प्रोग्रामर हूं जो कॉर्पोरेट जगत के लिए नया है। हाल ही में मैंने ग्रोवी और जावा का उपयोग कर एक आवेदन विकसित किया है। कोड के माध्यम से मैंने लिखा था कि स्टैटिक्स के काफी अच्छे संख्या में इस्तेमाल किया गया था। मुझे इस्तेमाल की जाने वाली स्टैटिक्स की संख्या में कटौती करने के लिए सीनियर टेक्निकल लॉ ने पूछा था। मैं उसी के बारे में चले गए हैं, और मुझे लगता है कि कई प्रोग्रामर स्थैतिक चर का उपयोग करने के विरुद्ध काफी हैं।

मुझे स्थिर चर का उपयोग करने के लिए अधिक सुविधाजनक लगता है और मुझे लगता है कि वे भी कुशल हैं (कृपया मुझे सही करें यदि मैं गलत हूं), क्योंकि अगर मुझे एक कक्षा में एक फ़ंक्शन में 10,000 कॉल करने Class.methodCall() , तो मुझे इस पद्धति को स्थैतिक बनाने और एक सीधा Class.methodCall() उपयोग करने में खुशी होगी। Class.methodCall() बजाय कक्षा के 10,000 उदाहरणों के साथ स्मृति को ढंकने के बजाय, सही है?

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

पी एस: कृपया मुझे सही कर दें यदि स्थिति के बारे में मेरी मान्यताओं गलत हैं

Solutions Collecting From Web of "स्थिर चर को बुरा क्यों माना जाता है?"

स्थैतिक चर वैश्विक राज्य का प्रतिनिधित्व करते हैं। इसके बारे में सोचने के लिए कठिन और मुश्किल है: अगर मैं किसी वस्तु का एक नया उदाहरण बना देता हूं, तो मैं परीक्षण के भीतर अपनी नई स्थिति के बारे में सोच सकता हूं। अगर मैं कोड का उपयोग करता हूं जो स्थिर चर का उपयोग कर रहा है, तो यह किसी भी स्थिति में हो सकता है – और कुछ भी इसे संशोधित कर सकता है।

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

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

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

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

कुछ पुन: उपयोग को रोकता है: इसके अलावा, स्थिर इंटरफेस को लागू करने के लिए स्थैतिक तरीकों का उपयोग नहीं किया जा सकता है, इसलिए स्थैतिक तरीकों कुछ ऑब्जेक्ट उन्मुख सुविधाओं को प्रयोग करने योग्य होने से रोका जा सकता है।

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

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

ईविल एक व्यक्तिपरक शब्द है।

आप निर्माण और विनाश के संदर्भ में स्थिति को नियंत्रित नहीं करते हैं। वे प्रोग्राम लोड हो रहा है और उतराई के आदेश पर रहते हैं।

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

ये उनके साथ दो मुख्य मुद्दे हैं I

नहीं। ग्लोबल राज्यों में बुरा नहीं है। लेकिन हमें यह देखने के लिए आपका कोड देखना होगा कि आपने इसे ठीक से उपयोग किया है या नहीं। यह काफी संभव है कि एक नौसिखिया वैश्विक राज्यों का दुरुपयोग करता है; जैसे वह प्रत्येक भाषा की सुविधा को दुर्व्यवहार करेगा

वैश्विक राज्य पूर्ण आवश्यकता हैं हम वैश्विक राज्यों से नहीं बच सकते हम वैश्विक राज्यों के बारे में तर्क से बच नहीं सकते। – यदि हमें हमारे आवेदन शब्दों को समझना है तो

जो लोग वैश्विक स्तरों से छुटकारा पाने की कोशिश करते हैं, अनिवार्य रूप से एक और अधिक जटिल प्रणाली के साथ समाप्त होता है – और वैश्विक राज्य अभी भी वहां हैं, चतुराई से / बेवकूफ़ बनाये गए कई परतों के तहत प्रलोभन; और हमें अभी भी ग्लोबल स्टेटस के बारे में तर्क देना है, जिसमें सभी indirections खोलने के बाद

वसंत के लोगों की तरह, जो कि विशुद्ध रूप से एक्सएमएल में वैश्विक राज्य घोषित करते हैं और किसी तरह सोचते हैं कि यह श्रेष्ठ है।

@जॉन स्कीट if I create a new instance of an object अब आपके पास दो चीजें हैं – ऑब्जेक्ट के भीतर राज्य, ऑब्जेक्ट की मेजबानी करने वाले पर्यावरण की स्थिति

स्थिर चर के साथ 2 मुख्य समस्याएं हैं:

  • थ्रेड सुरक्षा – स्थिर संसाधन परिभाषा से नहीं हैं धागा-सुरक्षित
  • कोड इम्प्लीसिटी – आप नहीं जानते कि जब एक स्थिर चर का तत्त्व होता है और चाहे वह एक और स्थिर वैरिएबल

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

मैं लगभग 85% समय का अनुमान लगाता हूं जब मैं 'अंतिम' बिना एक 'स्थिर' देखता हूं, यह गलत है अक्सर, मुझे मुखौटा या इन समस्याओं को छिपाने के लिए अजीब कार्य मिल जाएगा I

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

स्थिति का प्रयोग करना बहुत ही सूक्ष्म बग बना सकता है जिससे दर्द को बनाए रखने के इंजीनियरों के दिनों का कारण होगा। मुझे पता है, क्योंकि मैंने इन बग्स को बनाया और शिकार किया है

यदि आप अधिक विवरण चाहते हैं, तो कृपया पढ़ें …

स्टैटिक्स का उपयोग क्यों नहीं करें?

स्टैटिक्स के साथ कई मुद्दे हैं, जिनमें लेखन और निष्पादन परीक्षण शामिल हैं, साथ ही सूक्ष्म बग जो तुरंत स्पष्ट नहीं हैं

कोड जो स्थिर ऑब्जेक्ट्स पर निर्भर करता है, वह आसानी से यूनिट का परीक्षण नहीं हो सकता, और स्टैटिक्स को आसानी से मजाक नहीं किया जा सकता (आमतौर पर)।

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

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

एक बेहतर तरीका ग्राहकडाओ को इन्स्तांत करना है, और जब इसे बनाया गया है, ग्राहक फाइल्टर में पास करें। (एक बेहतर दृष्टिकोण स्प्रिंग या कंट्रोल फ्रेमवर्क के दूसरे उलटा प्रयोग के लिए होगा

एक बार जब आप ऐसा करते हैं, तो आप अपने CustomerFilterTest में एक वैकल्पिक डीएओ जल्दी से नकली या ठूंठ कर सकते हैं, जिससे आप परीक्षण पर अधिक नियंत्रण प्राप्त कर सकते हैं,

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

टेस्ट का निष्पादन

स्टैटिक्स एक वास्तविक समस्या का कारण बनता है जब एक साथ यूनिट परीक्षणों के सुइट चलाते हैं (उदाहरण के लिए, आपके सतत एकीकरण सर्वर के साथ) नेटवर्क के एक स्थिर मानचित्र की कल्पना करें सॉकेट ऑब्जेक्ट्स जो कि एक टेस्ट से दूसरे तक खुला रहता है। पहला परीक्षण पोर्ट 8080 पर सॉकेट खोल सकता है, लेकिन आप जब टेस्ट टूट जाए तो मैप को साफ़ करने के लिए भूल गए। अब दूसरी टेस्ट लॉन्च होने पर, पोर्ट 8080 के लिए एक नया सॉकेट बनाने की कोशिश करते समय यह दुर्घटनाग्रस्त हो सकता है, क्योंकि पोर्ट अभी भी कब्जा है यह भी कल्पना कीजिए कि आपके स्थैतिक संग्रह में गर्तिका संदर्भ नहीं हटाए जाते हैं, और (WeakHashMap के अपवाद के साथ) कचरा एकत्रित करने के लिए कभी पात्र नहीं हैं, जिससे स्मृति रिसाव हो सकता है।

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

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

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

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

इससे भी बदतर, असफलता उस आदेश के आधार पर हो सकती है जिसमें टेस्ट चलाए गए थे।

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

सूक्ष्म कीड़े

यदि आप उच्च उपलब्धता वाले वातावरण में काम करते हैं, या कहीं भी थ्रेड्स शुरू हो सकते हैं और रोका जा सकता है, तो यूनिट टेस्ट सूट के ऊपर उल्लिखित समान चिंताएं आपके कोड के उत्पादन पर भी चल सकती हैं।

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

जब कोई धागा मर जाता है, तो एक स्थिर ऑब्जेक्ट रीसेट या कचरा एकत्रित नहीं होता। कल्पना कीजिए कि आपके पास "ईमेल ग्राहक" नामक एक धागा है, और जब यह प्रारंभ हो जाता है तो यह एक स्थैतिक स्ट्रिंग संग्रह को ईमेल पते की सूची के साथ पॉप्युलेट करता है, तब प्रत्येक पते को ईमेल करना शुरू होता है कहें कि धागा किसी भी तरह से बाधित या रद्द किया जाता है, इसलिए आपकी उच्च उपलब्धता ढांचा धागा को पुनरारंभ करता है। तब जब धागा शुरू होता है, यह ग्राहकों की सूची को पुनः लोड करता है लेकिन क्योंकि संग्रह स्थिर है, यह पिछले संग्रह से ईमेल पते की सूची को बरकरार रख सकता है। अब कुछ ग्राहक डुप्लिकेट ईमेल प्राप्त कर सकते हैं

एक तरफ: स्थिर अंतिम

"स्थिर अंतिम" का उपयोग प्रभावी रूप से एक सी #define के जावा समकक्ष है, हालांकि तकनीकी कार्यान्वयन अंतर हैं संकलन से पहले एसी / सी ++ # परिभाषित प्री-प्रोसेसर द्वारा कोड से बाहर स्वैप किया जाता है। एक जावा "स्थिर अंतिम" स्टेक पर स्मृति निवासी खत्म हो जाएगा। इस तरह, यह "परिभाषित const" चर में C ++ की तुलना में अधिक है, जैसा कि यह #define है

सारांश

मुझे उम्मीद है कि इससे कुछ बुनियादी कारणों की व्याख्या करने में सहायता मिलती है, क्योंकि स्टैटिक्स समस्याग्रस्त हैं यदि आप जावा ईई या स्प्रिंग जैसे आधुनिक जावा फ़्रेमवर्क का उपयोग कर रहे हैं, तो आप इन स्थितियों में से कई का सामना नहीं कर सकते हैं, लेकिन यदि आप बड़े पैमाने पर विरासत कोड के साथ काम कर रहे हैं, तो वे अधिक बार-बार हो सकते हैं।

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

स्टेटिक्स कोड के अन्य भागों पर अंतर-निर्भरता को कम करते हैं। वे सही राज्य धारक के रूप में कार्य कर सकते हैं

मुझे आशा है कि आप ताले का उपयोग करने के लिए तैयार हैं और विवाद से निपटना

* वास्तव में, प्रीति संगठन ने इसका उल्लेख किया।

अगर मुझे कक्षा में फ़ंक्शन के लिए 10,000 कॉल करने पड़ते हैं, तो मुझे इस पद्धति को स्थैतिक बनाने में खुशी होगी और क्लास के 10,000 उदाहरणों के साथ स्मृति को अव्यवस्था के बजाय उस पर सीधा क्लास.मैथॉल () का उपयोग करना होगा, है ना?

आपको डेटा के साथ एक वस्तु के साथ डेटा को ढांचा बनाने की आवश्यकता को संतुलित करना होगा, कुछ डेटा पर फ़ंक्शन के परिणाम की गणना करने की आवश्यकता के मुकाबले।

इसके अलावा स्टेटिक्स कोड के दूसरे हिस्सों पर अंतर-निर्भरता को कम करते हैं।

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

अन्य उत्तर भी स्थिति के अत्यधिक प्रयोग के खिलाफ अच्छे कारण प्रदान करते हैं।

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

कहा जा रहा है, नियमित रूप से स्थिर चर (आमतौर पर बुरा माना जाता है) और अंतिम स्थैतिक चर (उर्फ स्थिरांक; इतनी बुरी तरह नहीं) के बीच भेद करना महत्वपूर्ण है।

मेरी राय में यह प्रदर्शन के बारे में शायद ही कभी है, यह डिजाइन के बारे में है मैं स्थैतिक तरीकों के उपयोग के संबंध में गलत तरीकों के इस्तेमाल पर विचार नहीं करता (लेकिन मुझे लगता है कि आप वास्तव में विधि कॉल के बारे में बात कर रहे हैं)

यह सिर्फ तर्क को अलग करने और इसे एक अच्छी जगह देने के बारे में है। कभी-कभी जो स्थैतिक तरीकों का उपयोग करके जवाहरण ​​करते हैं, जिनमें से java.lang.Math एक अच्छा उदाहरण है। मुझे लगता है कि जब आप अपने अधिकांश वर्ग XxxUtil या Xxxhelper नाम Xxxhelper तो आप बेहतर अपने डिजाइन पर पुनर्विचार करेंगे।

यह सुझाव दिया जा सकता है कि ज्यादातर मामलों में जहां आप एक स्थिर चर का उपयोग करते हैं, आप वास्तव में सिंगलटन पैटर्न का उपयोग करना चाहते हैं

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

एक और कारण: कमजोरी

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

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

यदि आप स्थिर चर का उपयोग कर रहे हैं, तो वह टूट जाएगा। कीड़े महंगे हैं

संभावित मद्देनजर डेवलपर्स द्वारा एक .0001% प्रदर्शन में सुधार और मजबूती के बीच में, कई मामलों में मजबूती एक अच्छा विकल्प है।

लाभ:

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

नुकसान:

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

याद रखने वाली चीज़ें:

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

कैसे स्टेटिक ब्रेक इनकैप्सुलेशन:

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

जावा में स्थिर तरीकों का उपयोग करने के कुछ बुनियादी फायदे और नुकसान का सारांश:

लाभ:

  1. विश्व स्तर पर पहुंच योग्य अर्थात् किसी विशेष ऑब्जेक्ट उदाहरण के साथ बंधे नहीं।
  2. प्रति JVM एक उदाहरण
  3. क्लास का नाम (कोई ऑब्जेक्ट की ज़रूरत नहीं) का उपयोग करके एक्सेस किया जा सकता है।
  4. सभी उदाहरणों के लिए एक एकल मूल्य लागू होता है
  5. JVM स्टार्टअप पर लोड करें और मर जाता है जब JVM बंद हो जाता है।
  6. वे ऑब्जेक्ट की स्थिति को संशोधित नहीं करते हैं

नुकसान:

  1. स्थैतिक सदस्य हमेशा मेमोरी के मौसम का हिस्सा होते हैं जो कि वे उपयोग में हैं या नहीं।
  2. आप स्थिर चर के निर्माण और विनाश को नियंत्रित नहीं कर सकते। कार्यक्रम लोड (या जब JVM बंद हो जाने पर) प्रोग्राम को लोड हो रहा है और नष्ट हो जाने पर उन्हें उपयोगी बनाया गया है।
  3. तुल्यकालन के जरिए आप स्टेटिक्स थ्रेड सुरक्षित बना सकते हैं लेकिन आपको कुछ अतिरिक्त प्रयासों की आवश्यकता है।
  4. यदि एक स्थिर चर के एक धागा परिवर्तन मूल्य जो अन्य थ्रेड्स की कार्यक्षमता को तोड़ सकता है
  5. इसका उपयोग करने से पहले आपको "स्थिर" पता होना चाहिए
  6. आप स्थिर तरीकों को ओवरराइड नहीं कर सकते।
  7. धारावाहिक उनके साथ अच्छी तरह से काम नहीं करता है
  8. They don't participate in runtime polymorphism.
  9. There is a memory issue (to some extent but not much I guess) if a large number of static variables/methods are used. Because they will not be GC until program ends.
  10. Static methods are hard to test too.

Static variables most importantly creates problem with security of data (any time changed,anyone can change,direct access without object, etc.)

For further info read this Thanks.

I find static variables more convenient to use. And I presume that they are efficient too (Please correct me if I am wrong) because if I had to make 10,000 calls to a function within a class, I would be glad to make the method static and use a straightforward class.methodCall() on it instead of cluttering the memory with 10,000 instances of the class, Right?

I see what you think, but a simple Singleton pattern will do the same without having to instantiate 10 000 objects.

static methods can be used, but only for functions that are related to the object domain and do not need or use internal properties of the object.

ex:

 public class WaterContainer { private int size; private int brand; ...etc public static int convertToGallon(int liters)... public static int convertToLiters(int gallon)... } 

The issue of 'Statics being evil' is more of an issue about global state. The appropriate time for a variable to be static, is if it does not ever have more than one state; IE tools that should be accessible by the entire framework and always return the same results for the same method calls are never 'evil' as statics. As to your comment:

I find static variables more convenient to use. And I presume that they are efficient too

Statics are the ideal and efficient choice for variables/classes that do not ever change .

The problem with global state is the inherent inconsistency that it can create. Documentation about unit tests often address this issue, since any time there is a global state that can be accessed by more than multiple unrelated objects, your unit tests will be incomplete, and not 'unit' grained. As mentioned in this article about global state and singletons , if object A and B are unrelated (as in one is not expressly given reference to another), then A should not be able to affect the state of B.

There are some exceptions to the ban global state in good code, such as the clock. Time is global, and–in some sense–it changes the state of objects without having a coded relationship.

Seems to me that you're asking about static variables but you also point out static methods in your examples.

Static variables are not evil – they have its adoption as global variables like constants in most cases combined with final modifier, but as it said don't overuse them.

Static methods aka utility method. It isn't generally a bad practice to use them but major concern is that they might obstruct testing.

As a example of great java project that use a lot of statics and do it right way please look at Play! framework . There is also discussion about it in SO.

Static variables/methods combined with static import are also widely used in libraries that facilitate declarative programming in java like: make it easy or Hamcrest . It wouldn't be possible without a lot of static variables and methods.

So static variables (and methods) are good but use them wisely!

My $.02 is that several of these answers are confusing the issue, rather than saying "statics are bad" I think its better to talk about scoping and instances.

What I would say is that a static is a "class" variables – it represenst a value that is shared across all instances of that class. Typically it should be scoped that way as well (protected or private to class and its instances).

If you plan to put class-level behavior around it and expose it to other code, then a singleton may be a better solution to support changes in the future (as @Jessica suggested). This is because you can use interfaces at the instance/singleton level in ways that you can not use at the class level – in particular inheritance.

Some thoughts on why I think some of the aspects in other answers are not core to the question…

Statics are not "global". In Java scoping is controlled separately from static/instance.

Concurrency is no less dangerous for statics than instance methods. It's still state that needs to be protected. Sure you may have 1000 instances with an instance variable each and only one static variable, but if the code accessing either isn't written in a thread-safe way you are still screwed – it just may take a little longer for you to realize it.

Managing life cycle is an interesting argument, but I think it's a less important one. I don't see why its any harder to manage a pair of class methods like init()/clear() than the creation and destroying of a singleton instance. In fact, some might say a singleton is a little more complicated due to GC.

PS, In terms of Smalltalk, many of its dialects do have class variables, but in Smalltalk classes are actually instances of Metaclass so they are really are variables on the Metaclass instance. Still, I would apply the same rule of thumb. If they are being used for shared state across instances then ok. If they are supporting public functionality you should look at a Singleton. Sigh, I sure do miss Smalltalk….

There's nothing wrong with static variables per se. It's just the Java syntax that's broken. Each Java class actually defines two structures- a singleton object which encapsulates static variables, and an instance. Defining both in the same source block is pure evil, and results in a code that's hard to read. Scala did that right.

I have just summarized some of the points made in the answers. If you find anything wrong please feel free to correct it.

Scaling: We have exactly one instance of a static variable per JVM. Suppose we are developing a library management system and we decided to put the name of book a static variable as there is only one per book. But if system grows and we are using multiple JVMs then we dont have a way to figure out which book we are dealing with?

Thread-Safety: Both instance variable and static variable need to be controlled when used in multi threaded environment. But in case of an instance variable it does not need protection unless it is explicitly shared between threads but in case of a static variable it is always shared by all the threads in the process.

Testing: Though testable design does not equal to good design but we will rarely observe a good design that is not testable. As static variables represent global state and it gets very difficult to test them.

Reasoning about state: If I create a new instance of a class then we can reason about the state of this instance but if it is having static variables then it could be in any state. क्यूं कर? Because it is possible that the static variable has been modified by some different instance as static variable is shared across instances.

Serialization: Serialization also does not work well with them.

Creation and destruction: Creation and destruction of static variables can not be controlled. Usually they are created and destroyed at program loading and unloading time. It means they are bad for memory management and also add up the initialization time at start up.

But what if we really need them?

But sometimes we may have a genuine need of them. If we really feel the need of many static variables that are shared across the application then one option is to make use of Singleton Design pattern which will have all these variables. Or we can create some object which will have these static variable and can be passed around.

Also if the static variable is marked final it becomes a constant and value assigned to it once cannot be changed. It means it will save us from all the problems we face due to its mutability.

a) Reason about programs.

If you have a small- to midsize-program, where the static variable Global.foo is accessed, the call to it normally comes from nowhere – there is no path, and therefore no timeline, how the variable comes to the place, where it is used. Now how do I know who set it to its actual value? How do I know, what happens, if I modify it right now? I have grep over the whole source, to collect all accesses, to know, what is going on.

If you know how you use it, because you just wrote the code, the problem is invisible, but if you try to understand foreign code, you will understand.

b) Do you really only need one?

Static variables often prevent multiple programs of the same kind running in the same JVM with different values. You often don't foresee usages, where more than one instance of your program is useful, but if it evolves, or if it is useful for others, they might experience situations, where they would like to start more than one instance of your program.

Only more or less useless code which will not be used by many people over a longer time in an intensive way might go well with static variables.

There are two main questions in your post.

First, about static variables. Static variables are completelly unnecesary and it's use can be avoided easily. In OOP languajes in general, and in Java particularlly, function parameters are pased by reference, this is to say, if you pass an object to a funciont, you are passing a pointer to the object, so you dont need to define static variables since you can pass a pointer to the object to any scope that needs this information. Even if this implies that yo will fill your memory with pointers, this will not necesary represent a poor performance because actual memory pagging systems are optimized to handle with this, and they will maintain in memory the pages referenced by the pointers you passed to the new scope; usage of static variables may cause the system to load the memory page where they are stored when they need to be accessed (this will happen if the page has not been accesed in a long time). A good practice is to put all that static stuf together in some little "configuration clases", this will ensure the system puts it all in the same memory page.

Second, about static methods. Static methods are not so bad, but they can quickly reduce performance. For example, think about a method that compares two objects of a class and returns a value indicating which of the objects is bigger (tipical comparison method) this method can be static or not, but when invoking it the non static form will be more eficient since it will have to solve only two references (one for each object) face to the three references that will have to solve the static version of the same method (one for the class plus two, one for each object). But as I say, this is not so bad, if we take a look at the Math class, we can find a lot of math functions defined as static methods. This is really more eficient than putting all these methods in the class defining the numbers, because most of them are rarelly used and including all of them in the number class will cause the class to be very complex and consume a lot of resources unnecesarilly.

In concluson: Avoid the use of static variables and find the correct performance equilibrium when dealing with static or non static methods.

PS: Sorry for my english.

everything (can:) have its purpose, if you have bunch of threads that needs to share/cache data and also all accessible memory (so you dont split into contexts within one JVM) the static is best choice

-> of course you can force just one instance, but why?
i find some of the comments in this thread evil, not the statics 😉

All the answers above show why statics are bad. The reason they are evil is because it gives the false impression that you are writing object oriented code, when in fact you are not. That is just plain evil.

Static variables are not good nor evil. They represent attributes that describe the whole class and not a particular instance. If you need to have a counter for all the instances of a certain class, a static variable would be the right place to hold the value.

Problems appear when you try to use static variables for holding instance related values.

There are plenty of good answers here, adding to it,

Memory: Static variables are live as long as the class loader lives[in general till VM dies], but this is only in-case of bulk objects/references stored as static.

Modularization: consider concepts like IOC, dependencyInjection, proxy etc.. All are completely against tightly coupling/static implementations.

Other Con's: Thread Safety, Testability

Think that if you have an application with many users and you have define a static form, then every user will modify all other forms of other users too.

Static means global, whenever you mark a variable as static , you make it visible and shared between all instances of a class.

In multi-threaded environments, marking a variable as static would allow multiple threads to access and modify it concurrently and that's would leave it in inconsistent state and lead to several serious problems, the debugging of such problems is very harmful.

Although developers normally tend to protect their static variables from concurrent modifications using for example Synchronized blocks, it is a time-consuming task to always surround each modification with a Synchronized block and there's a high possibility that the developer forget to protect some modification code by mistake.

The common usage of static variables is for defining constants, try to diminish the usage of them as much as you can unless you have a very specific business case which couldn't be solved better without static variable ie when you define an auto generated ID field in a class.

For much details, check Static keyword in java

I think excessive uses of global variables with static keyword will also leads to memory leakage at some point of instance in the applica