What Types of Objects Can Be Thrown in Java?

What kinds of objects can be thrown in Java? Is it possible to throw arbitrary objects or primitives by disabling the bytecode verifier?

In Java, the conventional approach dictates that only instances of the Throwable class, including its subclasses, can be thrown. However, there are intriguing questions surrounding the potential to circumvent this limitation, particularly through manipulation of the Java Virtual Machine (JVM).

public class CustomException extends Exception {\n    public CustomException(String message) {\n        super(message);\n    }\n}\n\n// Example of throwing a CustomException\ntry {\n    throw new CustomException("This is a custom exception");\n} catch (CustomException e) {\n    System.out.println(e.getMessage());\n}

Causes

• Java's enforced type safety: The JVM is designed to ensure only Throwable objects can be thrown to maintain stability and predictability in the code execution.
• Security measures: Attempting to throw non-Throwable objects could jeopardize application safety and lead to unpredictable behavior.

Solutions

• Use exceptions properly: To throw arbitrary objects, define custom exceptions that hold the necessary data and extend the Throwable class.
• Avoid JVM manipulation: Engaging in actions such as disabling the bytecode verifier is not recommended as it can lead to significant security vulnerabilities and unstable applications.

Mistake: Attempting to throw primitive types directly.

Solution: Wrap primitives in their respective object types (e.g., Integer, Double) or use custom exceptions.

Mistake: Ignoring the type safety enforced by the JVM leading to runtime exceptions.

Solution: Always adhere to the typing rules of Java, ensuring all thrown objects are instances of Throwable.