जावा कोडिंग शैली, स्थानीय चर बनाम बार-बार विधि कॉल

Question

मैं एक ही विधि में एकाधिक कॉल के बजाय स्थानीय चर का उपयोग करना पसंद करता हूं।

/* 
* I prefer this 
*/ 
Vehicle vehicle = person.getVehicle() 
if (vehicle instanceof Car) { 
    Car car = (Car) vehicle; 
    car.openSunroof(); 
} else if (vehicle instanceof Bike) { 
    Bike bike = (Bike) vehicle; 
    bike.foldKickstand(); 
} 
/* 
* Rather than this 
*/ 
if (person.getVehicle() instanceof Car) { 
    Car car = (Car) person.getVehicle(); 
    car.openSunroof(); 
} else if (person.getVehicle() instanceof Bike) { 
    Bike bike = (Bike) person.getVehicle(); 
    bike.foldKickstand(); 
} 

• मुझे विश्वास है कि पहले जिस तरह से एक छोटा सा तेजी से प्रदर्शन करने के लिए जा रहा है
• मुझे लगता है कि दूसरा तरीका सूखी सिद्धांत
• मैं पहली बार जिस तरह से अधिक पठनीय और डिबग करने के लिए आसान लगता है (का उल्लंघन करती है ... ठीक नगण्य है क्योंकि मैं पर कदम सकता है)
• मैं बदली हुई वस्तु राज्य की संभावना से निपटने के लिए नहीं करना चाहती

आप कौन सा पसंद करते हैं और क्यों?

Answer 1

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

Answer 2

मैं सभी कारणों से आप उल्लेख किया है के लिए पहले संस्करण पसंद करते हैं। विशेष रूप से (सिर्फ अपने चौथे बिंदु उल्लेख करने के लिए), यह मतलब है कि आप निश्चित रूप से एक Bike पर सुसंगत परिणाम प्राप्त करने के लिए जा रहे हैं ... आप दूसरे संस्करण के साथ बुरी तरह बुरा परिणाम मिल सकता है अगर getVehicle() पहली कॉल पर एक Car लौटे, तो दूसरा ...

प्रदर्शन पक्ष मुझे परेशान नहीं करता है (उदाहरण के लिए मैं खुशी से List.size() पर कॉल करूंगा) लेकिन पठनीयता, स्थिरता और गैर-दोहराना सभी महत्वपूर्ण हैं। अनिवार्य रूप से पहला स्निपेट "मान प्राप्त करें, फिर इसका उपयोग करें" के विचार को दूसरे की तुलना में अधिक प्रभावी ढंग से व्यक्त करता है।

तो हाँ, मैं तुम्हारे साथ हूँ ... किसी को भी आप के लिए दूसरा रूप की सिफारिश की जाती है?

Answer 3

मैं मानता हूँ, लेकिन मैं भी 'instanceof' के उपयोग को कम करने के लिए, वर्ग डिजाइन के स्तर पर प्रयास करें।

Answer 4

मुझे व्यक्तिगत रूप से लगता है कि पहला क्लीनर है। हालांकि, प्रदान की गई विधि कुछ गणना गहन नहीं है, इससे कोई फर्क नहीं पड़ता।

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

Answer 5

मैं सामान्य रूप से अतिरिक्त वेरिएबल के प्रवर्तन नापसंद जोड़ा राज्य के हर बिट एक विधि को और अधिक जटिल बना देता है के रूप में। लेकिन यहां तक ​​कि मैं कहूंगा कि यह आपके उदाहरण में जरूरी है क्योंकि परिवर्तक समान कोड की 4 पुनरावृत्ति को प्रतिस्थापित करता है।

लेकिन परिवर्तक निश्चित रूप से final होना चाहिए!

Answer 6

हर कोई है कि इस सवाल का अब तक जवाब के रूप में, मैं निश्चित रूप से पहले शैली पसंद करते हैं। यह भी क्लीनर हो सकता है हालांकि:

Vehicle vehicle = person.getVehicle() 
if (vehicle instanceof Car) { 
    ((Car) vehicle).openSunroof(); 
} else if (vehicle instanceof Bike) { 
    ((Bike) vehicle).foldKickstand(); 
} 

Answer 7

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