Thread: Customer exception

public class MainClassCutsom {

public static void main(String[] args) throws CustomExceptionClass{

Scanner in = new Scanner(System.in);
System.out.println("Enter the player name");
String playerName = in.nextLine();
System.out.println("Enter the player age");
Integer age = Integer.parseInt(in.nextLine());
CustomExceptionClass c = new CustomExceptionClass(playerName, age);

try {
if(c.getAge() >= 19) {
c.displayDetails();
} else {
throw new CustomExceptionClass("InvalidAgeRangeException");
}
} catch(Exception e) {
System.out.println("CustomException:"+e.getMessage ());
}
in.close();
}
}

I just want to know that the way i constructed this code is a good practice or not. Becaus, when i used only throws and throw keyword the output which i got in the console is in red lines and track race, which i don't want that way to see my output. For that I've used this catch block to print the right message which i got like this below.

Output:
---------
Enter the player name
kumar
Enter the player age
12
CustomException:InvalidAgeRangeException

Using try-catch blocks to handle exceptions is a common practice, especially when you want to provide more specific error messages or handle exceptions gracefully without showing stack traces directly to the user. However, it's essential to handle exceptions appropriately based on the context and requirements of your application.

In your case, you're catching `Exception` which is a general catch-all for any type of exception. While this ensures that your program won't crash unexpectedly, it's generally recommended to catch more specific exceptions whenever possible. This allows you to handle different types of exceptions differently if needed.

For instance, in your code, you're throwing a `CustomExceptionClass` for invalid age range. It would be better to catch only `CustomExceptionClass` rather than catching all exceptions. This ensures that you're only handling exceptions that you anticipate and explicitly handle.

Here's a modified version of your code with a more specific catch block:

```java
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("Enter the player name");
String playerName = in.nextLine();
System.out.println("Enter the player age");
Integer age = Integer.parseInt(in.nextLine());
CustomExceptionClass c = new CustomExceptionClass(playerName, age);

try {
if (c.getAge() >= 19) {
c.displayDetails();
} else {
throw new CustomExceptionClass("InvalidAgeRangeException");
}
} catch (CustomExceptionClass e) {
System.out.println("CustomException: " + e.getMessage());
} finally {
in.close();
}
}
```

In this version, we catch only CustomExceptionClass, ensuring that we handle only the specific exception we expect to encounter. Additionally, I've moved the in.close() call to the finally block to ensure that the Scanner is always closed, even if an exception occurs. This is good practice to avoid resource leaks. If you find yourself needing further help with Java assignment, there are plenty of online resources available like ProgrammingHomeworkHelp.com assignment help platform, where you can seek guidance and support.