S15L01 - IntellJ Idea डिबगर अवलोकन

html

IntelliJ IDEA में Java डिबगिंग में महारत हासिल करना: एक व्यापक मार्गदर्शिका
विषय सूची

परिचय ............................................................................... 1
IntelliJ IDEA में डिबगिंग को समझना .................................. 3

2.1 डिबगिंग क्या है? ......................................................... 3
2.2 Java विकास में डिबगिंग का महत्व ..................... 4


डेबगर सेट अप करना .......................................................... 6

3.1 डिबग सेटिंग्स को कॉन्फ़िगर करना ............................................. 6
3.2 डिबगर के साथ कमांड-लाइन आर्गुमेंट्स का उपयोग करना .......... 7


ब्रेकपॉइंट्स और वॉचपॉइंट्स .................................................. 9

4.1 ब्रेकपॉइंट्स सेट करना .......................................................... 9
4.2 वॉचपॉइंट्स लागू करना ................................................ 10
4.3 कंडीशनल ब्रेकपॉइंट्स ................................................... 12
4.4 कई ब्रेकपॉइंट्स का प्रबंधन ....................................... 14


कोड में कदम रखना ............................................................ 17

5.1 स्टेप ओवर ................................................................. 17
5.2 स्टेप इंटू ................................................................. 18
5.3 स्टेप आउट ................................................................. 19
5.4 फोर्स स्टेप इंटू .......................................................... 20


उन्नत डिबगिंग सुविधाएँ ............................................... 23

6.1 वेरिएबल्स की जांच करना ..................................................... 23
6.2 वेरिएबल वैल्यूज़ को तुरंत बदलना ............................ 24
6.3 वेरिएबल्स पैनल का उपयोग करना ......................................... 25
6.4 मल्टीथ्रेडेड एप्लिकेशंस के साथ काम करना .................... 26


प्रभावी डिबगिंग के लिए सर्वोत्तम प्रथाएँ .................................... 29

7.1 ब्रेकपॉइंट्स को व्यवस्थित करना ................................................... 29
7.2 लॉग्स का प्रभावी उपयोग करना ................................................... 30
7.3 डिबगर प्रदर्शन को अनुकूलित करना ................................ 31


निष्कर्ष ................................................................................. 34
पूरक जानकारी ........................................................ 36

9.1 तुलना तालिका: वॉचपॉइंट्स बनाम ब्रेकपॉइंट्स ................. 36
9.2 नमूना प्रोग्राम कोड ..................................................... 38
9.3 अतिरिक्त संसाधन .................................................. 42




परिचय
Java डेवलपर्स के लिए डिबगिंग एक आवश्यक कौशल है जो कुशल और त्रुटि-मुक्त कोड लिखने के लिए प्रयासरत हैं। एकीकृत विकास पर्यावरणों (IDEs) के क्षेत्र में, IntelliJ IDEA एक शक्तिशाली उपकरण के रूप में उजागर होता है जिसमें एक मजबूत debugger है जो डिबगिंग प्रक्रिया को सरल बनाता है। यह ईबुक IntelliJ IDEA में debugger का उपयोग करने की जटिलताओं में गहराई से प्रवेश करती है, शुरुआती और बुनियादी ज्ञान वाले डेवलपर्स को आवश्यक विशेषताओं और सर्वोत्तम प्रथाओं के माध्यम से मार्गदर्शन करती है।
डिबगिंग टूल्स का प्रभावी ढंग से उपयोग करना आपके कोडिंग वर्कफ़्लो में महत्वपूर्ण रूप से वृद्धि कर सकता है, जिससे मुद्दों की पहचान और उन्हें जल्दी से ठीक करना आसान हो जाता है। इस मार्गदर्शिका में डिबगर सेट अप करने से लेकर ब्रेकपॉइंट्स और वॉचपॉइंट्स का उपयोग करने, कोड में कदम रखने और उन्नत डिबगिंग सुविधाओं का लाभ उठाने तक सब कुछ शामिल है। इस ईबुक के अंत तक, आपके पास IntelliJ IDEA का उपयोग करके Java एप्लिकेशन्स को कुशलतापूर्वक डिबग करने की व्यापक समझ होगी।
Pros:

बग्स की पहचान और उन्हें ठीक करके कोड की गुणवत्ता बढ़ाता है
कोड निष्पादन प्रवाह की समझ में सुधार करता है
विकास प्रक्रिया में समय बचाता है

Cons:

यदि प्रभावी ढंग से उपयोग नहीं किया गया तो यह समय-सापेक्ष हो सकता है
शुरुआत करने वालों के लिए सीखने की आवश्यकता हो सकती है

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


विषय
कब उपयोग करें
कहाँ लागू करें


Breakpoints
निर्धारित बिंदुओं पर कोड का निरीक्षण करने के लिए निष्पादन को रोकना
कोड के किसी भी महत्वपूर्ण अनुभाग में


Watchpoints
विशिष्ट वेरिएबल्स में परिवर्तनों की निगरानी करना
वेरिएबल्स जो महत्वपूर्ण परिणामों को प्रभावित करते हैं


Conditional Breakpoints
विशिष्ट शर्तों के आधार पर निष्पादन को रोकना
संदर्भ-विशिष्ट निरीक्षण की आवश्यकता वाले परिदृश्यों में



IntelliJ IDEA में डिबगिंग को समझना
2.1 डिबगिंग क्या है?
डिबगिंग एक व्यवस्थित प्रक्रिया है जिसके द्वारा सॉफ़्टवेयर एप्लिकेशन्स में बग्स या दोषों की पहचान, विश्लेषण और हटाए जाते हैं। इसमें प्रोग्राम को एक नियंत्रित वातावरण में चलाना शामिल होता है जहां डेवलपर निष्पादन प्रवाह की निगरानी कर सकता है, वेरिएबल्स की जांच कर सकता है, और एप्लिकेशन की स्थिति को विभिन्न बिंदुओं पर मूल्यांकन कर सकता है।
2.2 Java विकास में डिबगिंग का महत्व
Java विकास में, डिबगिंग यह सुनिश्चित करने के लिए महत्वपूर्ण है कि एप्लिकेशन्स वांछित रूप से चलें। यह में मदद करता है:

तार्किक त्रुटियों की पहचान: कोड में गलतियों का पता लगाना जो गलत व्यवहार की ओर ले जाती हैं।
प्रदर्शन को अनुकूलित करना: प्रदर्शन बाधाओं का पता लगाना और उन्हें हल करना।
कोड की गुणवत्ता बढ़ाना: यह सुनिश्चित करना कि कोड मजबूत, विश्वसनीय और रखरखाव योग्य है।

प्रभावी डिबगिंग अधिक स्थिर और कुशल एप्लिकेशन्स की ओर ले जाती है, जो अंततः उपयोगकर्ता अनुभव को बेहतर बनाती है और रखरखाव लागत को कम करती है।

डेबगर सेट अप करना
3.1 डिबग सेटिंग्स को कॉन्फ़िगर करना
IntelliJ IDEA में डिबगिंग शुरू करने के लिए, आपको डिबगर सेटिंग्स को उचित रूप से कॉन्फ़िगर करना होगा। इन चरणों का पालन करें:

कॉन्फ़िगरेशन सेटिंग्स खोलें:

शीर्ष टूलबार पर जाएं और कॉन्फ़िगरेशन सेटिंग्स आइकन (आमतौर पर एक रिंच या गियर जैसा दिखता है) खोजें।


Edit Configurations:

Edit Configurations पर क्लिक करें ताकि रन/डिबग कॉन्फ़िगरेशन्स डायलॉग तक पहुंच सकें।


Main Class सेट करें:

यह सुनिश्चित करें कि सही Main Class चयनित है, विशेष रूप से यदि आपके प्रोग्राम में कई main मेथड्स हैं।


अप्लाई और सेव करें:

कॉन्फ़िगर करने के बाद, सेटिंग्स को सेव करने के लिए Apply और फिर OK पर क्लिक करें।



चित्र 3.1: IntelliJ IDEA में कॉन्फ़िगरेशन सेटिंग्स संपादित करना

3.2 डिबगर के साथ कमांड-लाइन आर्गुमेंट्स का उपयोग करना
IntelliJ IDEA आपको डिबगिंग के दौरान अपने प्रोग्राम में कमांड-लाइन आर्गुमेंट्स पास करने की अनुमति देता है। यहां है कैसे:

Run/Debug Configurations तक पहुंचें:

Run > Edit Configurations पर जाएं।


Arguments जोड़ें:

Program Arguments सेक्शन में, वांछित कमांड-लाइन आर्गुमेंट्स इनपुट करें।


अप्लाई और डिबग करें:

निर्दिष्ट आर्गुमेंट्स के साथ प्रोग्राम चलाने के लिए Apply पर क्लिक करें और फिर Debug करें।



नमूना प्रोग्राम कोड: कमांड-लाइन आर्गुमेंट्स का उपयोग करना




		
		
			
			
Java
			
			public class DebugDemo {
    public static void main(String[] args) {
        if (args.length > 0) {
            System.out.println("Command-Line Arguments:");
            for (String arg : args) {
                System.out.println(arg);
            }
        } else {
            System.out.println("No command-line arguments provided.");
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						public class DebugDemo {
    public static void main(String[] args) {
        if (args.length > 0) {
            System.out.println("Command-Line Arguments:");
            for (String arg : args) {
                System.out.println(arg);
            }
        } else {
            System.out.println("No command-line arguments provided.");
        }
    }
}
					
				
			
		


व्याख्या:

प्रोग्राम जांचता है कि क्या कोई कमांड-लाइन आर्गुमेंट्स प्रदान किए गए हैं।
यदि आर्गुमेंट्स मौजूद हैं, तो यह प्रत्येक को प्रिंट करता है; अन्यथा, यह उपयोगकर्ता को सूचित करता है कि कोई आर्गुमेंट्स नहीं दिए गए हैं।

आउटपुट उदाहरण:




		
		
			
			
Java
			
			Command-Line Arguments:
Debugging
IntelliJ IDEA
Java
			
				
					
				
					1
2
3
4
				
						Command-Line Arguments:
Debugging
IntelliJ IDEA
Java
					
				
			
		



ब्रेकपॉइंट्स और वॉचपॉइंट्स
4.1 ब्रेकपॉइंट्स सेट करना
ब्रेकपॉइंट्स वे मार्कर्स होते हैं जिन्हें आप कोड की विशिष्ट लाइनों पर सेट कर सकते हैं ताकि आपके प्रोग्राम का निष्पादन उन बिंदुओं पर रुके। यह आपको एप्लिकेशन की स्थिति की जांच करने और इसके व्यवहार को समझने की अनुमति देता है।
ब्रेकपॉइंट सेट करने का तरीका:

लाइन का पता लगाएं:

एडिटर में Java फाइल खोलें।


गटर पर क्लिक करें:

उस लाइन नंबर के बगल के बाएं मार्जिन (गटर) पर क्लिक करें जहां आप ब्रेकपॉइंट सेट करना चाहते हैं। एक लाल बिंदु प्रकट होगा, जो ब्रेकपॉइंट को दर्शाता है।



ब्रेकपॉइंट्स के साथ नमूना कोड:




		
		
			
			
Java
			
			public class BreakpointExample {
    public static void main(String[] args) {
        int x = 5; // यहां ब्रेकपॉइंट
        int y = x + 10;
        System.out.println("Value of y: " + y);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public class BreakpointExample {
    public static void main(String[] args) {
        int x = 5; // यहां ब्रेकपॉइंट
        int y = x + 10;
        System.out.println("Value of y: " + y);
    }
}
					
				
			
		


व्याख्या:

ब्रेकपॉइंट int x = 5; लाइन पर सेट किया गया है। डिबग करते समय, प्रोग्राम निष्पादन को इस लाइन पर रोक देगा, जिससे आप x के मान की जांच कर सकते हैं इससे पहले कि यह बदलता है।

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

वेरिएबल की पहचान करें:

उस वेरिएबल को चुनें जिसे आप मॉनिटर करना चाहते हैं।


वॉच जोड़ें:

वेरिएबल पर राइट-क्लिक करें और Add Watch चुनें या मैन्युअली वेरिएबल को जोडने के लिए Watch पैनल का उपयोग करें।



वॉचपॉइंट के साथ नमूना कोड:




		
		
			
			
Java
			
			public class WatchpointExample {
    static int count = 0;

    public static void main(String[] args) {
        increment();
        System.out.println("Count: " + count);
    }

    public static void increment() {
        count += 1; // 'count' पर वॉचपॉइंट सेट
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						public class WatchpointExample {
    static int count = 0;
 
    public static void main(String[] args) {
        increment();
        System.out.println("Count: " + count);
    }
 
    public static void increment() {
        count += 1; // 'count' पर वॉचपॉइंट सेट
    }
}
					
				
			
		


व्याख्या:

स्टेटिक वेरिएबल count पर वॉचपॉइंट सेट किया गया है। प्रत्येक बार count बदलने पर, डिबगर निष्पादन को रोक देगा, जिससे आप प्रोग्राम निष्पादन के दौरान इसके मान पर नज़र रख सकते हैं।

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

ब्रेकपॉइंट सेट करें:

वांछित लाइन पर ब्रेकपॉइंट सेट करें।


शर्त जोड़ें:

ब्रेकपॉइंट पर राइट-क्लिक करें और Condition चुनें।


शर्त परिभाषित करें:

शर्त अभिव्यक्ति दर्ज करें, जैसे x == 10।



उदाहरण:




		
		
			
			
Java
			
			public class ConditionalBreakpointExample {
    public static void main(String[] args) {
        for (int x = 0; x <= 20; x++) {
            System.out.println("x = " + x);
            // ब्रेकपॉइंट शर्त x == 10 के साथ
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						public class ConditionalBreakpointExample {
    public static void main(String[] args) {
        for (int x = 0; x <= 20; x++) {
            System.out.println("x = " + x);
            // ब्रेकपॉइंट शर्त x == 10 के साथ
        }
    }
}
					
				
			
		


व्याख्या:

लूप के अंदर ब्रेकपॉइंट सेट है जिसमें शर्त x == 10 है। डिबगर केवल तभी निष्पादन को रोक देगा जब x 10 तक पहुंचता है, जिससे आप उस विशिष्ट पुनरावृत्ति पर प्रोग्राम की स्थिति का निरीक्षण कर सकते हैं।

4.4 कई ब्रेकपॉइंट्स का प्रबंधन
बड़े प्रोजेक्ट्स पर काम करते समय, आपको कई ब्रेकपॉइंट्स का कुशलतापूर्वक प्रबंधन करने की आवश्यकता हो सकती है। IntelliJ IDEA ब्रेकपॉइंट्स को देखने, सक्षम/अक्षम करने और उन्हें आवश्यकता अनुसार हटाने के लिए उपकरण प्रदान करता है।
ब्रेकपॉइंट्स का प्रबंधन करना:

सभी ब्रेकपॉइंट्स देखें:

ब्रेकपॉइंट्स डायलॉग खोलने के लिए Ctrl + Shift + F8 (Windows/Linux) या Cmd + Shift + F8 (Mac) दबाएं।


ब्रेकपॉइंट्स को सक्षम/अक्षम करें:

विशिष्ट ब्रेकपॉइंट्स को बिना उन्हें हटाए सक्षम या अक्षम करने के लिए चेकबॉक्स का उपयोग करें।


ब्रेकपॉइंट्स हटाएं:

ब्रेकपॉइंट का चयन करें और इसे हटाने के लिए Remove बटन पर क्लिक करें।



सर्वोत्तम प्रथाएँ:

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


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




		
		
			
			
Java
			
			public class StepOverExample {
    public static void main(String[] args) {
        int a = 5;
        int b = add(a, 10); // यहां स्टेप ओवर
        System.out.println("Result: " + b);
    }

    public static int add(int x, int y) {
        return x + y;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						public class StepOverExample {
    public static void main(String[] args) {
        int a = 5;
        int b = add(a, 10); // यहां स्टेप ओवर
        System.out.println("Result: " + b);
    }
 
    public static int add(int x, int y) {
        return x + y;
    }
}
					
				
			
		


व्याख्या:

int b = add(a, 10); पर ब्रेकपॉइंट सेट करने और स्टेप ओवर का उपयोग करने से add मेथड को स्टेप इंटू किए बिना निष्पादित किया जाएगा, जिससे आप जल्दी से अगली लाइन पर आगे बढ़ सकते हैं।

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




		
		
			
			
Java
			
			public class StepIntoExample {
    public static void main(String[] args) {
        int a = 5;
        int b = multiply(a, 10); // यहां स्टेप इंटू
        System.out.println("Result: " + b);
    }

    public static int multiply(int x, int y) {
        return x * y;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						public class StepIntoExample {
    public static void main(String[] args) {
        int a = 5;
        int b = multiply(a, 10); // यहां स्टेप इंटू
        System.out.println("Result: " + b);
    }
 
    public static int multiply(int x, int y) {
        return x * y;
    }
}
					
				
			
		


व्याख्या:

int b = multiply(a, 10); पर ब्रेकपॉइंट सेट करने और स्टेप इंटू का उपयोग करने से आप multiply मेथड के अंदर पहुंच जाएंगे, जिससे आप इसके लॉजिक का डिबग कर सकते हैं।

5.3 स्टेप आउट
Step Out निष्पादन को जारी रखता है जब तक कि वर्तमान मेथड रिटर्न नहीं कर देता, प्रभावी ढंग से उससे बाहर कदम रखता है। 
उपयोग परिदृश्य:
जब आप एक मेथड का डिबग करना समाप्त कर चुके हैं और बिना मेथड के शेष कोड के माध्यम से कदम रखे कॉलर पर लौटना चाहते हैं।
उदाहरण:




		
		
			
			
Java
			
			public class StepOutExample {
    public static void main(String[] args) {
        int a = 5;
        int b = calculate(a, 10); // यहां से स्टेप आउट
        System.out.println("Result: " + b);
    }

    public static int calculate(int x, int y) {
        int result = x + y;
        return result;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						public class StepOutExample {
    public static void main(String[] args) {
        int a = 5;
        int b = calculate(a, 10); // यहां से स्टेप आउट
        System.out.println("Result: " + b);
    }
 
    public static int calculate(int x, int y) {
        int result = x + y;
        return result;
    }
}
					
				
			
		


व्याख्या:

calculate मेथड में कदम रखने और इसके लॉजिक की जांच करने के बाद, स्टेप आउट का उपयोग करने से आप main मेथड पर वापस आ जाएंगे, जिससे आप वहां से डिबगिंग जारी रख सकते हैं।

5.4 फोर्स स्टेप इंटू
Force Step Into स्टेप इंटू से गहराई में जाता है, जिससे आप उन मेथड्स में भी कदम रख सकते हैं जो सामान्य स्टेपिंग के माध्यम से एक्सेस नहीं किए जा सकते (जैसे, लाइब्रेरी मेथड्स)। 
उपयोग परिदृश्य:
जब आपको ऐसी मेथड्स की आंतरिक कार्यान्वयन को डिबग करने की आवश्यकता हो जो आमतौर पर डेवलपर से छिपी होती हैं।
उदाहरण:




		
		
			
			
Java
			
			public class ForceStepIntoExample {
    public static void main(String[] args) {
        String text = "Hello, World!";
        int length = text.length(); // यहां फोर्स स्टेप इंटू
        System.out.println("Length: " + length);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public class ForceStepIntoExample {
    public static void main(String[] args) {
        String text = "Hello, World!";
        int length = text.length(); // यहां फोर्स स्टेप इंटू
        System.out.println("Length: " + length);
    }
}
					
				
			
		


व्याख्या:

text.length() पर फोर्स स्टेप इंटू का उपयोग करके, आप String क्लास के length मेथड में नेविगेट कर सकते हैं ताकि आप इसके निष्पादन की जांच कर सकें, जो सामान्यतः डेवलपर से छिपा होता है।


उन्नत डिबगिंग सुविधाएँ
IntelliJ IDEA उन्नत डिबगिंग सुविधाओं का एक सूट प्रदान करता है जो डिबगिंग के अनुभव को बढ़ाता है, इसे अधिक कुशल और जानकारीपूर्ण बनाता है।
6.1 वेरिएबल्स की जांच करना
Variables Panel वर्तमान स्कोप में सभी वेरिएबल्स का विस्तृत दृश्य प्रदान करता है, उनके नाम, प्रकार, और वर्तमान मान प्रदर्शित करता है।
विशेषताएँ:

रीयल-टाइम अपडेट्स: कोड में कदम रखने के दौरान वेरिएबल्स रीयल-टाइम में अपडेट होते हैं।
विस्तार योग्य ऑब्जेक्ट्स: आप ऑब्जेक्ट्स को विस्तार करके उनके आंतरिक फील्ड्स और नेस्टेड ऑब्जेक्ट्स देख सकते हैं।

उदाहरण:




		
		
			
			
Java
			
			public class VariableInspectionExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        person.setAge(31);
        System.out.println(person);
    }
}

class Person {
    private String name;
    private int age;

    // Constructor and getters/setters omitted for brevity
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						public class VariableInspectionExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        person.setAge(31);
        System.out.println(person);
    }
}
 
class Person {
    private String name;
    private int age;
 
    // Constructor and getters/setters omitted for brevity
}
					
				
			
		


व्याख्या:

डिबगिंग करते समय, Variables Panel person ऑब्जेक्ट को उसके name और age फील्ड्स के साथ प्रदर्शित करेगा, जिससे आप प्रत्येक कदम पर उनके मानों की जांच कर सकते हैं।

6.2 वेरिएबल वैल्यूज़ को तुरंत बदलना
IntelliJ IDEA आपको डिबगिंग के दौरान वेरिएबल्स के मानों को बदलने की अनुमति देता है, जिससे आप बिना एप्लिकेशन को पुनः आरंभ किए विभिन्न परिदृश्यों का परीक्षण कर सकते हैं।
वेरिएबल्स को बदलने का तरीका:

निष्पादन रोकें:

ब्रेकपॉइंट सेट करें और डिबगिंग शुरू करें।


वेरिएबल चुनें:

Variables Panel में, उस वेरिएबल पर राइट-क्लिक करें जिसे आप बदलना चाहते हैं।


मान सेट करें:

Set Value चुनें और नया वांछित मान दर्ज करें।



उदाहरण:




		
		
			
			
Java
			
			public class ModifyVariableExample {
    public static void main(String[] args) {
        int counter = 10;
        counter += 5; // यहां 'counter' को 20 पर बदलें
        System.out.println("Counter: " + counter);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public class ModifyVariableExample {
    public static void main(String[] args) {
        int counter = 10;
        counter += 5; // यहां 'counter' को 20 पर बदलें
        System.out.println("Counter: " + counter);
    }
}
					
				
			
		


व्याख्या:

डिबगिंग के दौरान, आप counter का मान 15 से बदलकर 20 कर सकते हैं इससे पहले कि println स्टेटमेंट चले, जिससे आप विभिन्न वेरिएबल मानों के साथ प्रोग्राम के व्यवहार का निरीक्षण कर सकते हैं।

6.3 वेरिएबल्स पैनल का उपयोग करना
Variables Panel विभिन्न कार्यात्मकताओं की पेशकश करता है जो वेरिएबल निरीक्षण को बढ़ाते हैं:

Watch Expressions: विशिष्ट वेरिएबल्स या गणनाओं को देखने के लिए एक्सप्रेशन्स जोड़ें।
Filtering: मौजूदा डिबगिंग आवश्यकताओं के लिए प्रासंगिक वेरिएबल्स पर ध्यान केंद्रित करने के लिए फिल्टर करें।
Grouping: बेहतर संगठन के लिए वेरिएबल्स को उनके स्कोप या प्रकार के आधार पर समूहित करें।

टिप्स:

Add Watches: नियमित रूप से उन वेरिएबल्स पर नज़र रखें जो आपके एप्लिकेशन की लॉजिक के लिए महत्वपूर्ण हैं।
Use Evaluations: प्रत्येक लाइन में कदम रखने के बजाय, Variables Panel के भीतर जटिल एक्सप्रेशन्स का परिणाम समझने के लिए सीधे उनकी मूल्यांकन का उपयोग करें।

6.4 मल्टीथ्रेडेड एप्लिकेशन्स के साथ काम करना
मल्टीथ्रेडेड एप्लिकेशन्स को डिबग करना चुनौतीपूर्ण हो सकता है क्योंकि थ्रेड्स का समांतर निष्पादन होता है। IntelliJ IDEA मल्टीथ्रेडेड एप्लिकेशन्स को प्रभावी ढंग से प्रबंधित और निरीक्षण करने के लिए उपकरण प्रदान करता है।
विशेषताएँ:

Thread Overview: Threads Panel में सभी सक्रिय थ्रेड्स को देखें।
Switching Threads: उनके राज्यों और वेरिएबल्स का निरीक्षण करने के लिए थ्रेड्स के बीच आसानी से स्विच करें।
Suspending Threads: निष्पादन प्रवाह को नियंत्रित करने के लिए थ्रेड्स को रोकें और फिर से शुरू करें।

उदाहरण:




		
		
			
			
Java
			
			public class MultithreadedDebugExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Task(), "Thread-1");
        Thread thread2 = new Thread(new Task(), "Thread-2");
        thread1.start();
        thread2.start();
    }
}

class Task implements Runnable {
    @Override
    public void run() {
        int x = 0;
        while (x < 5) {
            System.out.println(Thread.currentThread().getName() + " - x: " + x);
            x++;
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
				
						public class MultithreadedDebugExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Task(), "Thread-1");
        Thread thread2 = new Thread(new Task(), "Thread-2");
        thread1.start();
        thread2.start();
    }
}
 
class Task implements Runnable {
    @Override
    public void run() {
        int x = 0;
        while (x < 5) {
            System.out.println(Thread.currentThread().getName() + " - x: " + x);
            x++;
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
					
				
			
		


व्याख्या:

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


प्रभावी डिबगिंग के लिए सर्वोत्तम प्रथाएँ
सर्वोत्तम प्रथाओं का पालन आपके डिबगिंग प्रक्रिया को अधिक कुशल और कम त्रुटि-प्रवण बना सकता है। यहां कुछ प्रमुख रणनीतियाँ हैं जो आपके डिबगिंग कौशल को बढ़ाने में मदद करेंगी।
7.1 ब्रेकपॉइंट्स को व्यवस्थित करना
सही ढंग से अपने ब्रेकपॉइंट्स को व्यवस्थित करना सुनिश्चित करता है कि आप डिबगिंग सत्रों के दौरान उन्हें तेजी से नेविगेट और प्रबंधित कर सकें।
रणनीतियाँ:

Categorize Breakpoints: मॉड्यूल्स, फीचर्स, या कार्यक्षमता के आधार पर ब्रेकपॉइंट्स को समूहित करें।
Name Breakpoints: ब्रेकपॉइंट्स को उनके उद्देश्य को याद रखने के लिए वर्णनात्मक नाम दें।
Use Conditional Breakpoints: ब्रेकपॉइंट्स में शर्तें जोड़कर अनावश्यक रुके हुए ब्रेकपॉइंट्स को कम करें।

7.2 लॉग्स का प्रभावी उपयोग करना
लॉगिंग डिबगिंग के लिए एक पूरक उपकरण है, जो मैन्युअल निरीक्षण के बिना एप्लिकेशन के व्यवहार में अंतर्दृष्टि प्रदान करता है।
टिप्स:

Strategic Logging: अपने कोड में महत्वपूर्ण बिंदुओं पर लॉग स्टेटमेंट्स रखें ताकि निष्पादन प्रवाह और वेरिएबल्स की स्थिति को ट्रैक किया जा सके।
Different Log Levels: लॉग की वर्बोसिटी को नियंत्रित करने के लिए विभिन्न लॉग लेवल्स (INFO, DEBUG, ERROR) का उपयोग करें।
Analyze Log Outputs: पैटर्न और संभावित मुद्दों की पहचान के लिए नियमित रूप से लॉग आउटपुट्स की समीक्षा करें।

उदाहरण:




		
		
			
			
Java
			
			import java.util.logging.Logger;

public class LoggingExample {
    private static final Logger logger = Logger.getLogger(LoggingExample.class.getName());

    public static void main(String[] args) {
        logger.info("Application started.");
        int result = compute(5, 10);
        logger.info("Computation result: " + result);
    }

    public static int compute(int a, int b) {
        logger.debug("Computing the sum of " + a + " and " + b);
        return a + b;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						import java.util.logging.Logger;
 
public class LoggingExample {
    private static final Logger logger = Logger.getLogger(LoggingExample.class.getName());
 
    public static void main(String[] args) {
        logger.info("Application started.");
        int result = compute(5, 10);
        logger.info("Computation result: " + result);
    }
 
    public static int compute(int a, int b) {
        logger.debug("Computing the sum of " + a + " and " + b);
        return a + b;
    }
}
					
				
			
		


व्याख्या:

लॉग्स एप्लिकेशन घटनाओं का कालक्रमिक रिकॉर्ड प्रदान करते हैं, जिससे ट्रेसिंग और निदान मुद्दों में मदद मिलती है।

7.3 डिबगर प्रदर्शन को अनुकूलित करना
डिबगर का प्रभावी उपयोग समय और संसाधनों को बचा सकता है, विशेष रूप से बड़े प्रोजेक्ट्स पर काम करते समय।
रणनीतियाँ:

Limit Breakpoints: अत्यधिक ब्रेकपॉइंट्स से बचें ताकि डिबगर को ओवरवेल्म न किया जाए।
Use Evaluate Expression: प्रत्येक लाइन में कदम रखने के बजाय, जटिल एक्सप्रेशन्स को जल्दी से निरीक्षण करने के लिए Evaluate Expression फीचर का उपयोग करें।
Suspend Threads Selectively: संबंधित थ्रेड्स पर ध्यान केंद्रित करने के लिए थ्रेड्स को चयनपूर्वक रुके।


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

ब्रेकपॉइंट्स और वॉचपॉइंट्स: निष्पादन को रोकने और वेरिएबल परिवर्तनों की निगरानी के लिए मूलभूत उपकरण।
कोड में कदम रखना: निष्पादन प्रवाह को समझने और मुद्दों को ठीक करने के लिए आवश्यक।
उन्नत सुविधाएँ: वेरिएबल निरीक्षण, तुरंत संशोधन, और मल्टीथ्रेडिंग समर्थन का उपयोग करके डिबगिंग को सुगम बनाएं।
सर्वोत्तम प्रथाएँ: ब्रेकपॉइंट्स को व्यवस्थित करें, लॉगिंग का प्रभावी ढंग से उपयोग करें, और डिबगर प्रदर्शन को अनुकूलित करें ताकि कुशल डिबगिंग सत्र सुनिश्चित हो सके।

इन डिबगिंग रणनीतियों को अपनाकर अपने Java विकास कौशल को ऊंचा उठाएं और मजबूत, त्रुटि-मुक्त एप्लिकेशन्स बनाएं।
SEO Keywords: Java debugging, IntelliJ IDEA debugger, breakpoints, watchpoints, step over, step into, step out, conditional breakpoints, multithreaded debugging, debugging best practices, Java development tools, code inspection, variable monitoring, debugging techniques, IntelliJ IDEA tips, Java IDE debugging, efficient debugging, debugging tools, Java code troubleshooting

पूरक जानकारी
9.1 तुलना तालिका: वॉचपॉइंट्स बनाम ब्रेकपॉइंट्स


विशेषता
Breakpoints
Watchpoints


उद्देश्य
विशिष्ट कोड लाइनों पर निष्पादन को रोकना
किसी वेरिएबल के मान में परिवर्तन की निगरानी करना और रोकना


उपयोग
कुछ बिंदुओं पर प्रोग्राम की स्थिति का निरीक्षण करना
वेरिएबल संशोधनों को ट्रैक करना


सेटअप जटिलता
गटर पर क्लिक करके सेट करना सरल
वॉच करने के लिए वेरिएबल्स की पहचान करना आवश्यक


निष्पादन प्रभाव
शर्तों की परवाह किए बिना निष्पादन को रोकता है
केवल तब रोकता है जब वॉच किया गया वेरिएबल शर्तों को पूरा करता है


सामान्य उपयोग के मामले
डिबगिंग नियंत्रण प्रवाह, वेरिएबल्स की स्थिति का निरीक्षण
महत्वपूर्ण वेरिएबल्स की निगरानी, स्थिति परिवर्तनों का डिबग करना


9.2 नमूना प्रोग्राम कोड
प्रोग्राम: डिबगिंग डेमो




		
		
			
			
Java
			
			public class DebuggerDemo {
    static int x = 50;

    public static void main(String[] args) {
        System.out.println("Starting Debugger Demo");
        displayValue();
        modifyValue();
        System.out.println("Final Value of x: " + x);
    }

    public static void displayValue() {
        System.out.println("Value of x: " + x);
    }

    public static void modifyValue() {
        x = 10; // 'x' पर वॉचपॉइंट
        System.out.println("Value of x modified to: " + x);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						public class DebuggerDemo {
    static int x = 50;
 
    public static void main(String[] args) {
        System.out.println("Starting Debugger Demo");
        displayValue();
        modifyValue();
        System.out.println("Final Value of x: " + x);
    }
 
    public static void displayValue() {
        System.out.println("Value of x: " + x);
    }
 
    public static void modifyValue() {
        x = 10; // 'x' पर वॉचपॉइंट
        System.out.println("Value of x modified to: " + x);
    }
}
					
				
			
		


व्याख्या:

Breakpoints: main मेथड की लाइनों पर सेट किए गए हैं ताकि प्रवाह का निरीक्षण किया जा सके।
Watchpoints: स्टेटिक वेरिएबल x पर सेट किए गए हैं ताकि निष्पादन के दौरान इसके परिवर्तनों की निगरानी की जा सके।

Debugger Interaction:

प्रारंभिक रन: प्रारंभिक संदेश और x के प्रारंभिक मान को देखें।
modifyValue() पर ब्रेकपॉइंट: मेथड में कदम रखें ताकि देखें कि x 50 से 10 में कैसे बदलता है।
x पर वॉचपॉइंट: x के संशोधित होने पर स्वतः रुकें, जिससे परिवर्तन से पहले और बाद का निरीक्षण संभव हो।
अंतिम आउटपुट: संशोधनों के बाद x के अंतिम मान की पुष्टि करें।

आउटपुट:




		
		
			
			
Java
			
			Starting Debugger Demo
Value of x: 50
Value of x modified to: 10
Final Value of x: 10
			
				
					
				
					1
2
3
4
				
						Starting Debugger Demo
Value of x: 50
Value of x modified to: 10
Final Value of x: 10
					
				
			
		


9.3 अतिरिक्त संसाधन
IntelliJ IDEA और Java विकास में अपने डिबगिंग कौशल को और बढ़ाने के लिए, निम्नलिखित संसाधनों का अन्वेषण करने पर विचार करें:

IntelliJ IDEA Documentation: आधिकारिक मार्गदर्शिका
Oracle द्वारा Java Tutorials: Java Debugging Techniques
Effective Java by Joshua Bloch: Java में सर्वोत्तम प्रथाओं पर एक व्यापक मार्गदर्शिका।
ऑनलाइन कोर्सेस:

Udemy: IntelliJ IDEA के साथ मास्टरींग Java Debugging
Coursera: Java Programming and Debugging


Community Forums:

Stack Overflow: विशिष्ट डिबगिंग प्रश्नों के लिए डेवलपर समुदाय के साथ सहभागिता करें।
JetBrains Community: IntelliJ IDEA से संबंधित चर्चाओं में भाग लें और समर्थन प्राप्त करें।



इन संसाधनों के साथ जुड़ने से आपको इस ईबुक में कवर किए गए अवधारणाओं के साथ गहरे अंतर्दृष्टि और व्यावहारिक ज्ञान प्राप्त होगा।
आउटपुट:

Note: यह लेख AI द्वारा जनरेट किया गया है।
विषय	कब उपयोग करें	कहाँ लागू करें
Breakpoints	निर्धारित बिंदुओं पर कोड का निरीक्षण करने के लिए निष्पादन को रोकना	कोड के किसी भी महत्वपूर्ण अनुभाग में
Watchpoints	विशिष्ट वेरिएबल्स में परिवर्तनों की निगरानी करना	वेरिएबल्स जो महत्वपूर्ण परिणामों को प्रभावित करते हैं
Conditional Breakpoints	विशिष्ट शर्तों के आधार पर निष्पादन को रोकना	संदर्भ-विशिष्ट निरीक्षण की आवश्यकता वाले परिदृश्यों में
विशेषता	Breakpoints	Watchpoints
उद्देश्य	विशिष्ट कोड लाइनों पर निष्पादन को रोकना	किसी वेरिएबल के मान में परिवर्तन की निगरानी करना और रोकना
उपयोग	कुछ बिंदुओं पर प्रोग्राम की स्थिति का निरीक्षण करना	वेरिएबल संशोधनों को ट्रैक करना
सेटअप जटिलता	गटर पर क्लिक करके सेट करना सरल	वॉच करने के लिए वेरिएबल्स की पहचान करना आवश्यक
निष्पादन प्रभाव	शर्तों की परवाह किए बिना निष्पादन को रोकता है	केवल तब रोकता है जब वॉच किया गया वेरिएबल शर्तों को पूरा करता है
सामान्य उपयोग के मामले	डिबगिंग नियंत्रण प्रवाह, वेरिएबल्स की स्थिति का निरीक्षण	महत्वपूर्ण वेरिएबल्स की निगरानी, स्थिति परिवर्तनों का डिबग करना