जावा के नुकसान। भाग 1

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

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

त्रुटि जाँच सूची:

1. टाइपो। कष्टप्रद टाइपोस जो तुरंत दिखाई नहीं देते हैं
2. तुलना के बजाय स्थिति में असाइनमेंट
3. स्थिति में तार्किक त्रुटियां
4. गलत स्ट्रिंग तुलना
5. आदिम प्रकारों के चर का गलत प्रारंभ
6. डबल का अनुचित उपयोग
7. कंस्ट्रक्टर में गलत प्रकार का रिटर्न वैल्यू।
8. शून्य से भाग। POSITIVE_INFINITY
9. वर्ग आरंभीकरण आदेश को ध्यान में नहीं रखते
10. एक स्थानीय चर एक वर्ग चर छुपाता है
11. अंकगणितीय अभिव्यक्तियों में स्वचालित कास्टिंग की अनदेखी करना
12. बाइट के साथ अनंत लूप, जिसका पता लगाना मुश्किल है।
13. कक्षा का नाम उस फ़ाइल के नाम से अलग है जिसमें यह संग्रहीत है।
14. ऐसी वस्तुएँ जो किसी सरणी के तत्व हैं, आरंभिक नहीं हैं।
15. सार्वजनिक संशोधक के साथ एक बार में कई कक्षाओं को एक फ़ाइल में रखना

जावा नुकसान

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

लेख के लिए, मैंने विशेष रूप से विस्तृत टिप्पणियों के साथ एक कार्य कोड लिखा। कोड उदाहरणों के साथ एक लेख लिखने के लिए, जावा 8 का उपयोग किया गया था। परीक्षण के लिए, जावा कोड को अलग-अलग पैकेज में रखा गया है।

उदाहरण: "पानी के नीचे पैकेज

शुरुआती लोगों को किन कठिनाइयों का सामना करना पड़ता है?

शुद्धिपत्र

ऐसा होता है कि नौसिखिए प्रोग्रामर टाइपोस बनाते हैं जो एक नज़र में पता लगाना मुश्किल है।


कोड उदाहरण:

फ़ाइल: "Simple.java"

/*   ;     */ package underwaterRocks.simple; /** * * @author Ar20L80 */ public class Simple { public static void main(String[] args) { int ival = 10; if(ival>0); { System.out.println("     "); } } } 

स्पष्टीकरण : “अर्धविराम कथन के अंत को इंगित करता है। इस मामले में; एक खाली बयान का अंत है। यह एक तार्किक भूल है। ऐसी त्रुटि का पता लगाना मुश्किल हो सकता है।

कंपाइलर विचार करेगा कि सब कुछ सही है। स्थिति अगर (ival> 0); इस मामले में कोई मतलब नहीं है। क्योंकि इसका मतलब है: यदि प्रतिद्वंद्वी शून्य से अधिक है, तो कुछ भी न करें और जारी रखें। "

तुलना के बजाय स्थिति में असाइनमेंट

स्थिति परिवर्तनशील असाइनमेंट है।

यह कोई गलती नहीं है, लेकिन इस तरह की तकनीक का उपयोग उचित होना चाहिए।

  boolean myBool = false; if(myBool = true) System.out.println(myBool); 

इस कोड में, अगर (myBool = true) का अर्थ है: "चर myBool को सही पर सेट करें,
यदि अभिव्यक्ति सही है, तो ब्रैकेट के बाद की स्थिति का पालन करें। "

इस कोड में, शर्त हमेशा सच होगी। और System.out.println (myBool); हालत की परवाह किए बिना, हमेशा निष्पादित किया जाएगा।

== समानता के लिए एक तुलना है।
= एक असाइनमेंट है, आप एक = 10 कह सकते हैं; जैसे: "लेकिन 10 का मान असाइन करें"।

कोष्ठक में स्थिति एक बूलियन मान लौटाता है।
इससे कोई फर्क नहीं पड़ता कि आप किस क्रम में लिखते हैं। आप इस तरह की तुलना कर सकते हैं: (0 == ए) या (5 == ए)
यदि आप एक समान चिह्न भूल जाते हैं, उदाहरण के लिए (0 = a) या (5 = a), तो संकलक आपको एक त्रुटि की सूचना देगा। आप एक मान प्रदान करते हैं, तुलना नहीं।
आप एक पठनीय रूप में कुछ अंतराल भी लिख सकते हैं।
उदाहरण के लिए: आपको लिखने की आवश्यकता है: 5 से अधिक और 10 से कम।
आप इस तरह लिखते हैं: (a> 4 && a <10), लेकिन उसी सफलता के साथ आप लिख सकते हैं: (4 <a && a <10),
अब आप देखते हैं कि इन मूल्यों को छोड़कर, 4 और 10 के बीच है। यह अधिक स्पष्ट है। यह तुरंत स्पष्ट है कि, इन मूल्यों को छोड़कर, 4 और 10 के बीच अंतराल में है।

कोड उदाहरण (अंतराल) 3.9 [):
अगर (3 <a && a <9) निष्पादित करें;

तार्किक त्रुटि

if (कंडीशन) {} if (कंडीशन) {} और {} - तो निकटतम को संदर्भित करता है यदि।
यह अक्सर शुरुआती गलतियों का कारण होता है।

अमान्य स्ट्रिंग तुलना

स्ट्रिंगर्स की तुलना करने के लिए शुरुआती अक्सर। = के बजाय। का उपयोग करते हैं।

चर आरंभीकरण

एक आदिम प्रकार के शुरुआती चर पर विचार करें।

आदिम (बाइट, शॉर्ट, इंट, लॉन्ग, चार, फ्लोट, डबल, बूलियन)।

प्रारंभिक मूल्य।

 byte 0 short 0 int 0 long 0L float 0.0f double 0.0d char '\u0000' String (or any object) null boolean false (  jvm) 

नोट:

स्थानीय चर थोड़े अलग होते हैं;
संकलक कभी भी एक असमान स्थानीय चर के लिए एक डिफ़ॉल्ट मान प्रदान नहीं करता है।

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

एक असिंचित स्थानीय चर पर पहुंचने के परिणामस्वरूप एक संकलन-समय त्रुटि होगी।

कोड में इस नोट की पुष्टि:

फ़ाइल: "MyInitLocal.java"

 /*         */ package underwaterRocks.myInit; /** * * @author Ar20L80 */ public class MyInitLocal { float classes_f; int classes_gi; public static void main(String[] args) { float f; int i; MyInitLocal myInit = new MyInitLocal(); /*         .*/ System.out.println("myInit.classes_f = " + myInit.classes_f); System.out.println("myInit.classes_gi = " + myInit.classes_gi); // System.out.println("f = " + f); // .     // System.out.println("f = " + i); // .     } } 

मूल्यों का रंग:

byte ( , 1 , [-128, 127])
short ( , 2 , [-32768, 32767])
int ( , 4 , [-2147483648, 2147483647])
long ( , 8 , [-922372036854775808,922372036854775807])
float ( , 4 )
double ( , 8 )
char ( Unicode, 2 , 16 , [0, 65535])
boolean ( /, int, JVM)

char: चार डेटा प्रकार एक एकल 16-बिट यूनिकोड वर्ण है। इसका न्यूनतम मूल्य '\ u0000' (या 0) और अधिकतम मूल्य '\' ओफ़्फ़ '(या 65,535 समावेशी) है।

Oracle दस्तावेज़ीकरण >>

आइए संख्या के साथ लंबे प्रकार के एक चर को शुरू करने का प्रयास करें: 922372036854775807।
हमारे लिए कुछ नहीं चलेगा। क्योंकि, यह इंट इंट का पूर्णांक शाब्दिक है।
एक लंबे शाब्दिक के साथ सही आरंभीकरण: 9223720368547478080L;

कोड उदाहरण:

फ़ाइल: "MyInitLocalLong.java"

 /*    long  */ package underwaterRocks.myInit; /** * * @author Ar20L80 */ public class MyInitLocalLong { public static void main(String[] args) { // long al = 922372036854775807; // integer number too large long bl = 922372036854775807L; //   } } 

वैरिएबल को इनिशियलाइज़ करते समय क्या देखना है।

इस प्रकार के एक चर के मूल्यों की सीमा। यह तथ्य कि चर एक निश्चित प्रकार के शाब्दिक के साथ आरंभिक है। स्पष्ट और निहित जातियों के लिए। प्रकार की संगतता पर।

प्रकार के पूर्णांक के गोले का उपयोग करते समय, आपको ऑटो पैकिंग और इन प्रकारों के ऑटो अनपैकिंग पर ध्यान देना चाहिए।

दोहरे का अनुचित उपयोग

यहां आपको स्पष्ट करने की आवश्यकता है। यह दोहरे प्रकार के दुरुपयोग के बारे में नहीं है।
हम सही ढंग से उपयोग करें। केवल परिणाम एक नौसिखिया प्रोग्रामर को आश्चर्यचकित कर सकता है।
फ़ाइल: "MinusDouble.java"

 /*   */ package underwaterRocks.tstDouble; /** * * @author vvm */ public class MinusDouble { public static void main(String[] args) { double a = 4.64; double b = 2.64; System.out.println("ab = "+(ab)); } } /*   run: ab = 1.9999999999999996 */ 

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

अवैध डबल तुलना

दोहरे प्रकार पर विचार करें।

कोड उदाहरण:

फ़ाइल: "MyDouble.java"

 /*    double  - double. */ package underwaterRocks.myDouble; /** * * @author Ar20L80 */ public class MyDouble { public static void main(String[] args) { double dx = 1.4 - 0.1 - 0.1 - 0.1 - 0.1; System.out.println("dx = " + dx); // dx = 0.9999999999999997 System.out.print(" (dx == 1.0):"); System.out.println(dx == 1.0); // false,   1.0   0.9999999999999997 /*   double*/ final double EPSILON = 1E-14; double xx = 1.4 - 0.1 - 0.1 - 0.1 - 0.1; double xy = 1.0; /*  xx c xy */ if (Math.abs(xx - xy) < EPSILON) System.out.println(xx + "    " + xy + " EPSILON = " + EPSILON); } } 

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

क्लास कंस्ट्रक्टर

वर्ग निर्माता वर्ग के नाम से मेल खाता है और कुछ भी नहीं देता है, शून्य भी नहीं।

कोड उदाहरण:

फ़ाइल: "MyConstructor.java"

 /*      ,  void    void -    */ package underwaterRocks.myConstructor; /** * * @author Ar20L80 */ public class MyConstructor { public MyConstructor(){ System.out.println("   void"); } public void MyConstructor(){ System.out.println("  c void"); } public static void main(String[] args) { MyConstructor myconst = new MyConstructor(); myconst.MyConstructor(); //    } } 

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

शून्य से भाग

आपको क्या लगता है कि ऐसे कोड के निष्पादन का परिणाम क्या होगा।

फ़ाइल: "DivisionByZero.java"

 /* */ package divisionByZero; import static java.lang.Double.POSITIVE_INFINITY; /** * * @author Ar20L80 */ public class DivisionByZero { public static void main(String[] args) { try{ float f = 12.2f; double d = 8098098.8790d; System.out.println(f/0); System.out.println(d/0); System.out.println(POSITIVE_INFINITY == f/0); System.out.println(POSITIVE_INFINITY == d/0); } catch (NumberFormatException ex) { System.out.println("NumberFormatException"); } catch (ArithmeticException ex) { System.out.println("ArithmeticException"); } } } 

कोड का उत्पादन होगा:

 Infinity Infinity true true 

पूर्णांक प्रकार को शून्य से विभाजित करना एक अंकगणितीय अपवाद देगा।

Java.lang.Double वर्ग निरंतर POSITIVE_INFINITY; को परिभाषित करता है POSITIVE_INFINITY;

 public static final float POSITIVE_INFINITY = 1.0d / 0.0d; 

इसे इन्फिनिटी के बराबर एक स्ट्रिंग में परिवर्तित किया जाता है।

प्रारंभिक आदेश

फ़ाइल: "InitClass.java"

 /*     */ package myInitClass; /** * * @author Ar20L80 */ public class InitClass { InitClass(){ //   System.out.print(""); } { //   System.out.print("3 "); } public static void main(String[] args) { System.out.print("2"); new InitClass(); } static { //    System.out.print("1"); } } 

सबसे पहले, सभी स्थिर ब्लॉकों को निष्पादित किया जाता है, फिर आरंभीकरण ब्लॉक, फिर क्लास कंस्ट्रक्टर।

इसे प्रदर्शित किया जाएगा: "123 कंस्ट्रक्टर"

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

 public class MyClass { private int val = 0; public MyClass(int val) { this.val = val; } } 

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

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

अंकगणित प्रकार की कास्टिंग स्वचालित रूप से की जाती है

यह कष्टप्रद त्रुटियां पैदा कर सकता है।

 // byte a = 1; // byte b = 1; // byte  = a + b; //  // byte a = (byte) 1; // byte b = (byte) 1; // byte  = a + b; //  

 //     —     . byte a = 1; byte b = 1; byte c = (byte) (a + b); 

 //     —  final // final byte a = 1; // final byte b = 1; // byte c = a + b; //    ,  a  b final 

एक स्ट्रिंग के साथ काम करते समय एक संभावित समाधान:

 byte bHundr = Byte.parseByte("100"); //      byte 

निम्न कोड में एक और त्रुटि दी गई है।

 for (byte i = 1; i <= 128; i++) { System.out.println(i); } 

इस मामले में, हमें एक अनंत लूप मिलता है।

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

सरणी तत्व वाले ऑब्जेक्ट को प्रारंभ नहीं किया गया है

 int[] cats = new int[10]; for(int i=0; i<cats.length;i++){ System.out.println("cats " + i + " = " + cats[i]); } 

इस उदाहरण में, हमारे पास आदिम प्रकार के तत्वों की एक सरणी है। और कुछ भी बुरा नहीं होता है जब हम उन्हें शुरू नहीं करते हैं। उन्हें डिफ़ॉल्ट मान सौंपा जाएगा। इस स्थिति में, मान = 0।

आइए एक और उदाहरण पर विचार करें, सरणी में आदिम के साथ नहीं, बल्कि सरणी में वस्तुओं के साथ।

 public class ArrInitObj { public static void main(String[] args) { MyObj[] cats = new MyObj[10]; for(int i=0; i<cats.length;i++){ System.out.println("cats " + i + " = " + cats[i]); System.out.println("cats " + i + ".val = " + cats[i].val); //    java.lang.NullPointerException } } } class MyObj{ public int val; } 

इस समस्या का हल सभी ऑब्जेक्ट चर का उपयोग करने से पहले उन्हें शुरू करना है। MyObj वर्ग के कंस्ट्रक्टर में प्रारंभ किया जा सकता है।

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

सार्वजनिक संशोधक के साथ एक बार में कई कक्षाओं को एक फ़ाइल में रखना
त्रुटि काफी दुर्लभ है। आईडीई आपको तुरंत चेतावनी देगा।
फ़ाइल का नाम सार्वजनिक वर्ग के नाम से मेल खाना चाहिए।

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

मुझे उम्मीद है कि आपको यह लेख अच्छा लगा होगा और यह उपयोगी लगा। मुझे आपकी टिप्पणियों, टिप्पणियों, सुझावों, इच्छाओं के लिए खुशी होगी। जारी रखा जाए। बल्कि, इस प्रकार है।

संदर्भ
ओरेकल जावा कोड डिजाइन दिशानिर्देश >>>

पुनश्च। मेरे दोस्त! आपकी सहायता के बिना मेरे पास प्रकाशन जारी रखने का कोई तरीका नहीं है। यानी कोई वित्तीय अवसर नहीं। यदि प्रकाशन ने वास्तव में आपकी मदद की और आप जारी रखना चाहते हैं, तो कृपया मेरा समर्थन करें। कहीं एक बटन है: "लेखक का समर्थन करें।"
मुझे आपकी समझ की उम्मीद है। आपका धन्यवाद प्रकाशित करने के अवसर के लिए हब्र का धन्यवाद।

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