जावा शब्दार्थ त्रुटियाँ | जावा प्रोग्रामर को सिमेंटिक एरर को क्यों स्वीकार करना चाहिए

Mar 08 2023

JAVA FLAMES में शामिल हों बहुत से लोगों को जावा कोड में सिमेंटिक एरर और सिंटैक्टिकल (सिंटैक्स) एरर के बीच का अंतर समझने में मुश्किल लगता है, लेकिन वे अलग हैं। जब आपके कोड का सिंटैक्स सही हो लेकिन कोड का उपयोग सही न हो तो आप सिमेंटिक त्रुटि देख सकते हैं।

जावा फ्लेम्स में शामिल हों

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

सिमेंटिक एरर क्या है ? सिमेंटिक त्रुटियों का पता कैसे लगाया जाता है
? · सामान्य सिमेंटिक त्रुटियाँ

सिमेंटिक एरर क्या है?

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

var a = 1 // No error
var b = 2 // No error
var c = 3 // No error
a + c = b

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

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

शब्दार्थ त्रुटियों का पता कैसे लगाया जाता है?

कंपाइलर द्वारा कुछ सिमेंटिक एरर (स्थैतिक सिमेंटिक एरर) का पता लगाया जाता है, जो त्रुटि के प्रकार और जावा स्रोत फ़ाइल में स्थिति का संकेत देने वाला एक संदेश उत्पन्न करता है जहां त्रुटि हुई (ध्यान दें कि वास्तविक त्रुटि स्थिति से पहले हो सकती है संकलक द्वारा संकेतित)।

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

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

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

सिमेंटिक एरर के साथ डिबगिंग इतना आसान नहीं है। आइए एक उदाहरण देखें।

/**
 * This program prints the total benefit for the company
 * 
*/
public class TotalBenefit {
 public static void main(String[] args) {
  int branch1 = 250; 
        int branch2 = 500;
        System.out.println("The total benefit is  $" + (branch1 * branch2));
 }
}

सामान्य सिमेंटिक त्रुटियाँ

असंगत प्रकार त्रुटि

शुरुआती लोगों में यह सिंटैक्स त्रुटि बहुत आम है। जावा जैसी संकलित प्रोग्रामिंग भाषाओं में, आप केवल संगत चरों को मान निर्दिष्ट कर सकते हैं।

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

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

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

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

"वैरिएबल <X> को इनिशियलाइज़ नहीं किया जा सकता है"

ऐसा तब होता है जब किसी विधि के भीतर घोषित स्थानीय चर प्रारंभ नहीं किया गया है। यह तब हो सकता है जब प्रारंभिक मान के बिना एक चर एक if स्टेटमेंट का हिस्सा हो।

int x;
if (condition) {
  x = 5;
}
System.out.println(x); // x may not have been initialized

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

"अपरिवर्तनीय प्रकार" त्रुटि तब होती है जब जावा कोड अवैध रूपांतरण करने का प्रयास करता है।

TypeInvocationConversionTest.java:12: inconvertible types
found   : java.util.ArrayList<java.lang.Class<? extends TypeInvocationConversionTest.Interface1>>
required: java.util.ArrayList<java.lang.Class<?>>
lessRestrictiveClassList = (ArrayList<Class<?>>) classList;
                                                 ^

"गैर स्थैतिक चर। . . एक स्थिर संदर्भ से संदर्भित नहीं किया जा सकता ”

यह त्रुटि तब होती है जब संकलक स्थैतिक विधि से गैर-स्थैतिक चर तक पहुँचने का प्रयास करता है

public class StaticTest {
private int count=0;
   public static void main(String args[]) throws IOException {
       count++; //compiler error: non-static variable count cannot be referenced from a static context
   }
}

हस्ताक्षर में चर को स्थिर घोषित करें।
कोड की जाँच करें क्योंकि यह स्थैतिक विधि में एक गैर-स्थैतिक वस्तु का उदाहरण बना सकता है।

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

class Sample {
  private int age;
  public void setAge(int a) {
    age=a;
  }
  public int getAge() {
    return age;
  }
  public static void main(String args[]) {
    System.out.println(“Age is:”+ getAge());
   }
  }

Exception in thread “main” java.lang.Error: Unresolved compilation problem:
Cannot make a static reference to the non–static method getAge() from the type Sample

जब एक सरणी घोषित की गई है, लेकिन आरंभ नहीं की गई है, तो आपको "(सरणी) <X> प्रारंभ नहीं हुआ" संदेश मिलेगा। सरणियाँ लंबाई में तय की जाती हैं इसलिए प्रत्येक सरणी को वांछित लंबाई के साथ आरंभ करने की आवश्यकता होती है ।

निम्नलिखित कोड स्वीकार्य है:

AClass[] array = {object1, object2}
  As is:
       AClass[] array = new AClass[2];
       …
       array[0] = object1;
       array[1] = object2;
  But not:
       AClass[] array;
       …
       array = {object1, object2};

यह समस्या तब होती है जब ऑपरेटरों का उपयोग प्रकारों के लिए किया जाता है, उनकी परिभाषा में नहीं।

ऑपरेटरों को केवल कुछ प्रकारों के लिए परिभाषित किया जाता है, हालांकि कुछ संख्यात्मक प्रकारों के बीच अंतर्निहित प्रकार के रूपांतरण की अनुमति है:

int a = 5; 
boolean b = true;
int c = a + b; // Error, can't add a boolean value double 
d = a + 1.4;  // OK, int is implicitly converted to double

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

परिशुद्धता का संभावित नुकसान

कभी-कभी आप कास्टिंग गलत तरीके से लागू कर सकते हैं। उदाहरण के लिए, एक फ्लोट को एक इंट में डालना ठीक काम करता है, लेकिन संख्या के दशमलव भाग के नुकसान पर।

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

यह त्रुटि तब उत्पन्न होती है जब किसी स्पष्ट प्रकार के कास्ट के बिना कम परिशुद्धता वाले चर के लिए उच्च परिशुद्धता का मान निर्दिष्ट करने का प्रयास किया जाता है। हैरानी की बात है, शायद, फ़्लोटिंग पॉइंट शाब्दिक प्रकार के होते हैं doubleऔर यदि आप एक प्रकार के चर के लिए असाइन करने का प्रयास करते हैं तो आपको यह संदेश मिलेगा float:

float sum = 0.0;  // Error, literal is not of type float

float sum = 0.0f;   // OK float sum = (float) 0.0;  // OK

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

स्कोपिंग को गलत तरीके से लागू करना

किसी विधि के अंदर आपके द्वारा घोषित किसी भी चर का एक ही दायरा होता है - आवेदन के अन्य भागों में दृश्यता, दूसरे शब्दों में - विधि के रूप में। नतीजतन, आप एक विधि के अंदर एक निजी स्थैतिक int चर घोषित नहीं कर सकते। इसके बजाय, आपको वैश्विक रूप से चर को इस तरह परिभाषित करना चाहिए:

public class PrivateVar
{
   // This declaration works.
   private static int PrivateInt = 3;
   public static void main(String[] args)
   {
      // This declaration doesn’t work.
      private static int PrivateInt = 3;
   }
}

जावा में सिमेंटिक एरर के कुछ अन्य सामान्य मामले यहां दिए गए हैं

बेमेल टाइप करें - C # में गलत प्रकार का उपयोग करने के कई तरीके हैं। उपरोक्त उदाहरण एक तरीका है। यहाँ कुछ अन्य संभावित तरीके दिए गए हैं: