docs(generics-exceptions): explain limitations and best practices of using generics in exception handling

WHAT:
- Added detailed documentation about why Java generics have limited applicability in exception handling.
- Covered key limitations caused by type erasure, checked exception rules, and runtime constraints.
- Highlighted best practices for safely leveraging generics in exception-related scenarios.

WHY:
- Java developers often wonder why generic exception classes are discouraged or fail at compile time.
- Clarifying the impact of type erasure and checked exceptions improves understanding of exception design.

KEY POINTS:
1. Type Erasure:
   - At runtime, Java erases generic type parameters.
   - This prevents retaining generic type info in exceptions, limiting their usefulness when catching or handling.

2. **Checked vs. Unchecked Exceptions**:
   - Checked exceptions must be explicitly declared.
   - You can’t design a generic method to throw arbitrary checked exceptions without declaring them.

3. Runtime Type Information:
   - Since exceptions are handled at runtime, generic type arguments are lost.
   - This makes generic exceptions less practical in real-world scenarios.

BEST PRACTICES:
- Use generic fields** in exception classes instead of making the class itself generic.
- Keep exception hierarchies simple; avoid complex generic inheritance to maintain readability.
- Ensure type-safe exception handling by being explicit with generic usage.

CONCLUSION:
- Full generic exception classes are not practical in Java due to erasure and runtime constraints.
- However, generics can still add value in fields and **utility methods for exceptions.
- Following best practices balances type safety with maintainable exception handling.

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

Author: Someshdiwan

Section24JavaGenerics/src/GenericExceptions/Challenges with Generics in Exceptions.txt

@@ -0,0 +1,30 @@
+Type Erasure: As mentioned earlier, Java’s type erasure makes it difficult to retain generic type information at runtime,
+limiting the usefulness of generics in exception handling.
+
+Checked vs. Unchecked Exceptions: Java has strict rules around checked exceptions.
+
+You can’t make a generic method throw arbitrary checked exceptions unless you declare those exceptions explicitly.
+
+Runtime Type Information: Since exceptions are usually thrown and caught at runtime, the type of the generic parameter
+will be lost, which might make generic exceptions less practical in certain scenarios.
+
+Best Practices with Generic Exceptions:
+Use generics in exception fields: Instead of making the exception class itself generic, use generic fields to store
+error-related information.
+
+Avoid overly complex exception hierarchies: Keep the use of generics in exceptions simple to maintain readability and
+prevent confusion.
+
+Type-safe exception handling: Always be mindful of how generic exceptions are used and caught to ensure type safety
+and code clarity.
+
+Conclusion:
+Although Java imposes several limitations on using generics with exceptions
+(primarily due to type erasure and runtime constraints),
+you can still leverage generics in a limited capacity to enhance the functionality and flexibility of exceptions.
+
+These include using generic fields, methods that throw generic exceptions, and handling various types of exceptions
+while maintaining type safety.
+
+Understanding these techniques allows you to make better use of Java’s generic features in advanced exception handling
+scenarios.