जावा अपवाद हैंडलिंग में महारत: थ्रो और थ्रोज़ का पूर्ण गाइड

1 1. परिचय
2 2. जावा में Exception Handling क्या है?
3 3. throw क्या है?
4 4. throws क्या है?
5 5. throw और throws के बीच अंतर
6 6. throws के उपयोग के लिए सर्वोत्तम प्रथाएँ
7 7. व्यावहारिक अपवाद प्रबंधन पैटर्न
8 8. अक्सर पूछे जाने वाले प्रश्न (FAQ)

1. परिचय

जब आप जावा में प्रोग्रामिंग शुरू करते हैं, तो आप अनिवार्य रूप से “exception handling” शब्द से मिलेंगे। विभिन्न कीवर्ड्स में, “throw” और “throws” शुरुआती लोगों के लिए विशेष रूप से भ्रमित करने वाले होते हैं क्योंकि वे दिखने में समान होते हैं लेकिन अलग-अलग उद्देश्यों की पूर्ति करते हैं।

जावा एक ऐसी भाषा है जिसे सुरक्षा और मजबूती को ध्यान में रखकर डिज़ाइन किया गया है, और यह त्रुटियों और अप्रत्याशित स्थितियों को सही ढंग से संभालने के लिए एक अंतर्निहित तंत्र प्रदान करता है। इस तंत्र को “exception handling” कहा जाता है। एक्सेप्शन हैंडलिंग प्रोग्राम की विश्वसनीयता और रखरखाव क्षमता को सुधारने में महत्वपूर्ण भूमिका निभाता है।

इस लेख में, हम “java throws” के उपयोग पर ध्यान केंद्रित करेंगे, एक्सेप्शन हैंडलिंग की बुनियाद से शुरू करके अक्सर पूछे जाने वाले प्रश्नों और सामान्य गलतियों तक पहुँचेंगे। यह गाइड विशेष रूप से उन लोगों के लिए उपयोगी है जो “throw” और “throws” के बीच अंतर को लेकर अनिश्चित हैं, या जो यह समझना चाहते हैं कि throws को प्रभावी ढंग से कहाँ और कैसे उपयोग किया जाए। हम व्यावहारिक जानकारी, टिप्स, और वास्तविक प्रोजेक्ट्स में अक्सर देखे जाने वाले नमूना कोड भी शामिल करेंगे, इसलिए कृपया अंत तक पढ़ें।

2. जावा में Exception Handling क्या है?

जावा प्रोग्राम लिखते समय, रनटाइम पर विभिन्न अप्रत्याशित स्थितियाँ उत्पन्न हो सकती हैं। उदाहरण के लिए, कोई फ़ाइल नहीं मिल सकती, शून्य से विभाजन की त्रुटि हो सकती है, या एरे की सीमा से बाहर पहुँचने का प्रयास किया जा सकता है। इन स्थितियों को “exceptions” कहा जाता है।

2.1 Exception Handling की बुनियादी अवधारणाएँ

Exception handling एक तंत्र है जो प्रोग्राम निष्पादन के दौरान उत्पन्न असामान्य स्थितियों (exceptions) का पता लगाता है और डेवलपर्स को उन्हें उचित रूप से संभालने की अनुमति देता है। जब कोई exception उत्पन्न होता है, तो प्रोग्राम को अचानक समाप्त करने के बजाय, जावा एप्लिकेशन को त्रुटि के प्रकार और सामग्री के आधार पर सार्थक प्रतिक्रिया देने में सक्षम बनाता है। इससे एप्लिकेशन की स्थिरता और उपयोगकर्ता अनुभव में सुधार होता है।

2.2 Checked Exceptions और Unchecked Exceptions

जावा में exceptions दो मुख्य श्रेणियों में विभाजित होते हैं।

Checked Exceptions

Checked exceptions वे होते हैं जिन्हें कंपाइल समय पर संभालना अनिवार्य होता है। उदाहरण के लिए फ़ाइल ऑपरेशन्स के दौरान IOException। इन exceptions को या तो try-catch ब्लॉक के माध्यम से पकड़ा जाना चाहिए या throws घोषणा के द्वारा कॉलर तक पहुँचाया जाना चाहिए।

try {
    FileReader fr = new FileReader("data.txt");
} catch (IOException e) {
    e.printStackTrace();
}

Unchecked Exceptions

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

2.3 Exception Handling क्यों आवश्यक है

Exception handling को सही ढंग से लागू करने से निम्नलिखित लाभ मिलते हैं:

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

जावा में Exception handling मजबूत एप्लिकेशन बनाने के लिए एक आवश्यक कौशल है। अगले अध्याय में, हम “throw” की बुनियाद समझाएँगे।

3. throw क्या है?

जावा में, “throw” एक कीवर्ड है जिसका उपयोग जानबूझकर एक exception उत्पन्न करने के लिए किया जाता है। जबकि exceptions अक्सर प्रोग्राम निष्पादन के दौरान स्वचालित रूप से उत्पन्न होते हैं, आप कुछ शर्तों के पूरा होने पर एक exception बनाना और उठाना चाह सकते हैं—इसी स्थिति में “throw” का उपयोग किया जाता है।

3.1 throw का बुनियादी उपयोग

“throw” स्पष्ट रूप से एक exception ऑब्जेक्ट बनाता है और उसे फेंकता है, जिससे एक exception उत्पन्न होता है। बुनियादी सिंटैक्स इस प्रकार है:

throw new ExceptionClass("Error message");

उदाहरण के लिए, यदि कोई अमान्य तर्क पास किया जाता है, तो आप इस तरह एक exception उठा सकते हैं:

public void setAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("Age must be zero or greater");
    }
    this.age = age;
}

इस उदाहरण में, जब आयु शून्य से कम होती है तो IllegalArgumentException फेंका जाता है।

3.2 आप अपवाद फेंकना क्यों चाहेंगे

“throw” का मुख्य उद्देश्य प्रोग्राम को तुरंत अवैध स्थितियों या नियम उल्लंघनों के बारे में सूचित करना है। यह बग्स को जल्दी पकड़ने में मदद करता है और अनपेक्षित व्यवहार को रोकता है।

उदाहरण शामिल हैं:

जब उपयोगकर्ता इनपुट मान्यकरण में विफल हो
जब अमान्य पैरामीटर या कॉन्फ़िगरेशन पास किए जाएँ
जब व्यावसायिक तर्क आगे की प्रक्रिया को रोकता है

3.3 throw के उपयोग पर नोट्स

जब “throw” का उपयोग करके कोई अपवाद फेंका जाता है, तो यह कॉलर तक पहुँचता है जब तक कि उसी मेथड में try-catch ब्लॉक द्वारा इसे संभाला न जाए। चेक्ड अपवादों (जैसे IOException) के लिए, मेथड को अपने सिग्नेचर में “throws” भी घोषित करना चाहिए। अनचेक्ड अपवादों के लिए, throws घोषणा वैकल्पिक है, लेकिन “throw” और “throws” के बीच अंतर को समझना उचित उपयोग के लिए आवश्यक है।

4. throws क्या है?

जावा प्रोग्राम लिखते समय, आप मेथड डिक्लेरेशन्स में “throws” कीवर्ड देख सकते हैं। throws कीवर्ड कॉलर को सूचित करने के लिए उपयोग किया जाता है कि मेथड निष्पादन के दौरान एक या अधिक अपवाद फेंक सकता है।

4.1 throws का मूल उपयोग

मेथड डिक्लेरेशन में अपवाद क्लास नाम निर्दिष्ट करके, throws कीवर्ड मेथड के भीतर उत्पन्न होने वाले किसी भी अपवाद को उसके कॉलर तक पहुँचाता है। विशेष रूप से, चेक्ड अपवादों को throws के साथ घोषित किया जाना चाहिए ताकि कॉलर उन्हें सही ढंग से संभाल सके।

public void readFile(String path) throws IOException {
    FileReader reader = new FileReader(path);
    // File reading process
}

इस उदाहरण में, FileReader का कंस्ट्रक्टर IOException फेंक सकता है, इसलिए मेथड को throws IOException घोषित करना चाहिए।

4.2 मेथड डिक्लेरेशन्स में अपवाद प्रसार

जब कोई मेथड throws घोषित करता है, तो उसके भीतर उत्पन्न होने वाले सभी अपवाद कॉलर तक पहुँचते हैं। कॉलर को तब या तो अपवाद को पकड़ना होगा या अपने स्वयं के throws को घोषित करके आगे प्रसारित करना होगा।

public void processFile() throws IOException {
    readFile("test.txt"); // readFile throws IOException, so this method must also declare throws
}

4.3 कई अपवादों की घोषणा

यदि कोई मेथड कई अपवाद फेंक सकता है, तो उन्हें throws कीवर्ड के बाद कॉमा-सेपरेटेड सूची के रूप में घोषित किया जा सकता है।

public void connect(String host) throws IOException, SQLException {
    // Network or database operations
}

4.4 throws की भूमिका और लाभ

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

5. throw और throws के बीच अंतर

हालांकि अक्सर भ्रमित होते हैं, “throw” और “throws” जावा के अपवाद-हैंडलिंग तंत्र में बहुत अलग भूमिकाएँ निभाते हैं। यह अध्याय उनके अंतर को स्पष्ट करता है और बताता है कि प्रत्येक को कब और कैसे सही ढंग से उपयोग किया जाए।

5.1 throw और throws के कार्यात्मक अंतर

Item	throw	throws
Role	Actually generates an exception	Declares that a method may throw exceptions
Usage	Used inside methods to throw exception objects	Used in method declarations to specify throwable exceptions
Target	Exception objects created with new	Both checked and unchecked exceptions
Example	throw new IOException(“Error occurred”);	public void sample() throws IOException
When required	When intentionally raising an exception	When a method may throw checked exceptions

5.2 प्रत्येक के उपयोग के स्थितियाँ

throw
तब उपयोग किया जाता है जब आप सक्रिय रूप से एक अपवाद उत्पन्न करना चाहते हैं—उदाहरण के लिए, जब अमान्य इनपुट या नियम उल्लंघन का पता चलता है।
उदाहरण: “यदि आयु शून्य से कम है, तो IllegalArgumentException फेंकेँ।”
throws
तब उपयोग किया जाता है जब कोई मेथड या कंस्ट्रक्टर अपवाद फेंक सकता है और कॉलरों को इसके बारे में सूचित करना आवश्यक होता है।
उदाहरण: “फ़ाइल ऑपरेशन्स या डेटाबेस एक्सेस को संभालने वाले मेथड्स में throws का उपयोग करें, जहाँ अपवाद अपेक्षित होते हैं।”

5.3 तुलना के लिए कोड उदाहरण

Example of throw:

public void setName(String name) {
    if (name == null || name.isEmpty()) {
        throw new IllegalArgumentException("Name cannot be empty");
    }
    this.name = name;
}

throws का उदाहरण:

public void loadConfig(String path) throws IOException {
    FileReader reader = new FileReader(path);
    // Configuration loading process
}

5.4 सारांश तालिका

Decision Point	throw	throws
Where it’s used	Inside a method	Method declaration
What it does	Generates an exception	Declares exception propagation
Who handles it	Thrown at the point of error	Handled by the caller
When required	Optional (only when needed)	Required for checked exceptions

throw और throws की भूमिकाएँ स्पष्ट रूप से अलग हैं, इसलिए किसे किस परिदृश्य में उपयोग करना है को समझना मजबूत अपवाद प्रबंधन की ओर पहला कदम है।

6. throws के उपयोग के लिए सर्वोत्तम प्रथाएँ

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

6.1 विशिष्ट अपवाद वर्ग निर्दिष्ट करें

throws घोषणाओं में, हमेशा संभव हो तो सबसे विशिष्ट अपवाद वर्ग निर्दिष्ट करें।
Exception या Throwable को व्यापक रूप से घोषित करने से बचें।
IOException या SQLException जैसे विशिष्ट अपवादों का उपयोग करके, कॉलर सटीक रूप से निर्धारित कर सकते हैं कि त्रुटियों को कैसे संभालना है।

अच्छा उदाहरण:

public void saveData() throws IOException {
    // File-saving process
}

इसे न करें:

public void saveData() throws Exception {
    // Too vague: unclear what exceptions may occur
}

6.2 अपवाद पदानुक्रम का उपयोग करें

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

6.3 Javadoc में @throws टैग का उपयोग करें

API या लाइब्रेरी प्रदान करते समय, आपको Javadoc टिप्पणियों में @throws टैग का उपयोग करके अपवादों का दस्तावेज़ीकरण करना चाहिए।
यह स्पष्ट रूप से उन स्थितियों को समझाता है जिनमें अपवाद उत्पन्न होते हैं, जिससे API उपयोगकर्ता सही अपवाद प्रबंधन लागू कर सकें।

/**
 * Reads a file.
 * @param filePath Path of the file to read
 * @throws IOException If the file cannot be read
 */
public void readFile(String filePath) throws IOException {
    // ...
}

6.4 अनावश्यक अपवाद पुनः-फेंकने से बचें

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

6.5 कस्टम अपवाद वर्गों का उपयोग

व्यावसायिक अनुप्रयोगों और बड़े सिस्टमों में, कस्टम अपवाद वर्ग परिभाषित करना और उन्हें throws घोषणाओं में शामिल करना सामान्य है।
यह त्रुटि कारणों और जिम्मेदारियों को स्पष्ट करने में मदद करता है, जिससे सिस्टम को बनाए रखना और विस्तारित करना आसान हो जाता है।

public class DataNotFoundException extends Exception {
    public DataNotFoundException(String message) {
        super(message);
    }
}

public void findData() throws DataNotFoundException {
    // Throw when data is not found
}

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

7. व्यावहारिक अपवाद प्रबंधन पैटर्न

जावा में अपवाद प्रबंधन केवल साधारण try-catch ब्लॉकों या throws घोषणाओं से अधिक है।
यह अध्याय वास्तविक विकास में आमतौर पर उपयोग किए जाने वाले व्यावहारिक पैटर्न और डिज़ाइन रणनीतियों को प्रस्तुत करता है।

7.1 try-with-resources के साथ संसाधन प्रबंधन

फ़ाइलों, नेटवर्क कनेक्शनों या डेटाबेस कनेक्शनों के साथ काम करते समय, अपवाद उत्पन्न होने पर भी संसाधनों को सही ढंग से रिलीज़ करना अत्यंत महत्वपूर्ण है। जावा 7 से, try-with-resources कथन संसाधनों को स्वचालित रूप से बंद करने की अनुमति देता है।

try (FileReader reader = new FileReader("data.txt")) {
    // File reading process
} catch (IOException e) {
    System.out.println("Failed to read file: " + e.getMessage());
}

यह सिंटैक्स सुनिश्चित करता है कि close() को स्वचालित रूप से कॉल किया जाए, भले ही अपवाद उत्पन्न हों, इससे संसाधन रिसाव को रोका जा सके।

7.2 कई अपवादों को कुशलतापूर्वक संभालना

जटिल संचालन कई प्रकार के अपवाद उत्पन्न कर सकते हैं।
जावा 7 से, आप मल्टी-कैच सुविधा का उपयोग करके एक ही कैच क्लॉज में कई अपवादों को कैच कर सकते हैं।

try {
    methodA();
    methodB();
} catch (IOException | SQLException e) {
    // Handle both exceptions here
    e.printStackTrace();
}

आप प्रत्येक अपवाद प्रकार के लिए अनुकूलित हैंडलिंग प्रदान करने के लिए कैच ब्लॉक्स को अलग भी कर सकते हैं।

7.3 अपवाद हैंडलिंग के लिए प्रदर्शन विचार

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

गलत उपयोग (अनुशंसित नहीं):

try {
    int value = array[index];
} catch (ArrayIndexOutOfBoundsException e) {
    // Bounds checking should be done beforehand
}

अनुशंसित उपयोग:

if (index >= 0 && index < array.length) {
    int value = array[index];
} else {
    // Out-of-range handling
}

7.4 लॉगिंग और सूचनाएँ

जब अपवाद उत्पन्न होते हैं तो समस्या निवारण के लिए उचित लॉगिंग और अलर्टिंग आवश्यक हैं।
व्यवसाय प्रणालियाँ अक्सर विस्तृत अपवाद जानकारी रिकॉर्ड करने के लिए लॉगिंग फ्रेमवर्क (जैसे, Log4j, SLF4J) का उपयोग करती हैं।

catch (Exception e) {
    logger.error("An error has occurred", e);
}

7.5 कस्टम रिकवरी लॉजिक लागू करना

कुछ मामलों में, एक संचालन को पुनः प्रयास करना, कॉन्फ़िगरेशन फाइलों को पुनः लोड करना, या उपयोगकर्ताओं को सूचित करना जैसी रिकवरी लॉजिक लागू करना उपयोगी होता है।
कार्यक्रम को तुरंत समाप्त करने के बजाय, जहाँ भी संभव हो, सेवा निरंतरता बनाए रखने का प्रयास करें।

व्यावहारिक अपवाद-हैंडलिंग तकनीकों को अपनाकर, आप विश्वसनीय और रखरखाव योग्य जावा अनुप्रयोग बना सकते हैं।

8. अक्सर पूछे जाने वाले प्रश्न (FAQ)

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

Q1. throw और throws के बीच मुख्य अंतर क्या है?

A1.
throw एक कीवर्ड है जो कार्यक्रम निष्पादन के दौरान अपवाद को वास्तव में उत्पन्न करता है।
throws विधि घोषणाओं में उपयोग किया जाता है ताकि घोषणा की जा सके कि विधि अपवाद फेंक सकती है।
→ इसे याद रखने का एक अच्छा तरीका: throw = “निष्पादित करें,” throws = “घोषित करें।”

Q2. throws का उपयोग करते समय मुझे किन बातों का ध्यान रखना चाहिए?

A2.
throws के साथ घोषित अपवादों को कॉलर द्वारा कैच किया जाना चाहिए या throws का उपयोग करके आगे प्रचारित किया जाना चाहिए।
चेक किए गए अपवादों के लिए, स्पष्ट हैंडलिंग अनिवार्य है।
यदि आप अपवाद को कैच या प्रचारित नहीं करते, तो कार्यक्रम संकलित नहीं होगा।

Q3. क्या throw और throws को एक साथ उपयोग किया जा सकता है?

A3.
हाँ।
एक सामान्य पैटर्न है कि विधि के अंदर throw का उपयोग करके अपवाद फेंकना और throws का उपयोग करके उसी अपवाद को घोषित करना ताकि यह कॉलर तक प्रचारित हो।

Q4. throws का उपयोग करके कई अपवाद कैसे घोषित करें?

A4.
throws कीवर्ड के बाद उन्हें अल्पविराम से अलग करके सूचीबद्ध करें।
उदाहरण: public void sample() throws IOException, SQLException

Q5. क्या अनचेक किए गए अपवादों के साथ throws का उपयोग करना चाहिए?

A5.
अनचेक अपवाद (जो RuntimeException को विस्तारित करते हैं) throws घोषणाओं की आवश्यकता नहीं रखते।
हालांकि, जब आप स्पष्ट रूप से कॉलर्स को सूचित करना चाहते हैं कि एक विधि एक विशिष्ट अनचेक अपवाद फेंक सकती है, तो throws का उपयोग किया जा सकता है, जो पठनीयता और API स्पष्टता में सुधार करता है।

Q6. क्या throws क्लॉज में Exception या Throwable घोषित करना ठीक है?

A6.
तकनीकी रूप से हाँ, लेकिन यह अनुशंसित नहीं है।
बहुत व्यापक अपवाद प्रकारों को घोषित करना अस्पष्ट कर देता है कि कौन से प्रकार की त्रुटियाँ हो सकती हैं और कॉलर पर उचित हैंडलिंग को कठिन बना देता है।
जहाँ भी संभव हो, ठोस अपवाद कक्षाओं का उपयोग करें।

Q7. क्या मुझे हमेशा throws में घोषित अपवादों को कैच करना पड़ता है?

A7.
जाँच किए गए अपवादों (checked exceptions) के लिए, कॉलर को या तो अपवाद को पकड़ना (catch) चाहिए या उसे throws का उपयोग करके आगे प्रसारित (propagate) करना चाहिए।
ऐसा न करने पर संकलन (compilation) त्रुटि उत्पन्न होगी।
अनजाँचित अपवादों (unchecked exceptions) के लिए इनमें से कोई भी आवश्यक नहीं है।

Q8. यदि मैं throws लिखना भूल जाऊँ तो क्या होता है?

A8.
यदि कोई विधि (method) जाँच किए गए अपवाद को throws करती है लेकिन उसे throws के साथ घोषित नहीं करती, तो संकलन‑समय (compile‑time) त्रुटि होगी।
अनजाँचित अपवादों के लिए, विधि बिना throws के भी सामान्य रूप से संकलित हो जाती है, लेकिन उचित त्रुटि प्रबंधन (error handling) अभी भी लागू किया जाना चाहिए।

जावा में अपवाद प्रबंधन (exception handling) की अपनी समझ को गहरा करने के लिए इस FAQ अनुभाग का उपयोग करें।