docs: Add best practices for designing custom exceptions in Java

WHAT this covers:
- Provides guidelines for creating effective custom exception classes.
- Emphasizes clarity, consistency, and proper use in application design.

WHY this matters:
- Custom exceptions help model domain-specific error conditions (e.g., LowBalanceException).
- Poorly designed exceptions lead to unreadable, hard-to-maintain code.
- Following best practices ensures exceptions are meaningful, actionable, and testable.

Key best practices:
1. Use descriptive names:
   - Name exceptions to reflect their purpose, e.g., `InsufficientFundsException`, `InvalidUserInputException`.
   - Improves debugging and readability.

2. Document your exceptions:
   - Include Javadoc or comments explaining:
     - What triggers the exception.
     - When it should be thrown.
     - How calling code is expected to handle it.

3. Don’t overuse exceptions:
   - Use them only for exceptional scenarios, not regular control flow.
   - Example: don’t throw an exception when a loop ends normally.

4. Be consistent:
   - Adopt naming conventions (e.g., always suffix with "Exception").
   - Follow consistent formatting and structure across all custom exceptions.

5. Test your exceptions:
   - Write unit tests to trigger the exception.
   - Ensure calling code handles it gracefully without breaking system stability.

Extra implementation tips:
- Provide constructors:
  ```java
  class MyException extends Exception {
      public MyException(String message) {
          super(message);
      }
      public MyException(String message, Throwable cause) {
          super(message, cause);
      }
  }

	•	Decide checked vs unchecked:
	•	Extend Exception → checked (forces handling).
	•	Extend RuntimeException → unchecked (optional handling).
	•	Use hierarchy wisely:
	•	Create base exception (e.g., BankingException) with specific subclasses (LowBalanceException, AccountNotFoundException).

Short key: java custom-exception design best-practices maintainability.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section18ExceptionHandling/src/CustomException.txt

@@ -1,4 +1,5 @@
-Best practices for creating custom exceptions
+Best practices for creating custom exceptions.
+
 There are some basic pointers to keep in mind while creating your own custom exceptions:
 
 Use descriptive names: Naming your custom exception clearly and descriptively helps to communicate the cause of the
@@ -11,7 +12,8 @@ what conditions trigger it, and how it should be handled.
 
 This will make it easier for other developers to understand how to use your custom exceptions in their own code.
 
-Don't overuse exceptions: Only use exceptions for exceptional conditions. Overusing exceptions can make your code harder to read and debug.
+Don't overuse exceptions: Only use exceptions for exceptional conditions.
+Overusing exceptions can make your code harder to read and debug.
 
 Be consistent: Follow a consistent naming and formatting convention for your custom exceptions.
 
@@ -22,5 +24,3 @@ Also, test how your code handles the exception, and make sure it reacts appropri
 
 By following these best practices, you can create custom exceptions that are effective,
 easy to use and help improve the overall reliability and maintainability of your code.
-
-So keep these tips in mind as you create your own custom exceptions and happy coding!