Java Exception Handling Quiz

Checked exceptions (like IOException) must be caught or declared in throws clause - this is enforced at compile-time. Unchecked exceptions (RuntimeException and its subclasses) do NOT require explicit handling. Checked exceptions extend Exception (not RuntimeException), while unchecked exceptions extend RuntimeException (which itself extends Exception).

By convention, exception class names should end with 'Exception' (e.g., IOException, NullPointerException), but this is not a strict requirement - it's a naming convention for clarity. Some exception types like Error and its subclasses don't follow this pattern. The statement claims it's a strict requirement, which is false - it's a convention, not a rule.

Java guarantees that the code inside a finally block will always execute before leaving a try-catch block, regardless of whether a return, break, or continue statement was executed earlier.

In Java, Exceptions represent recoverable conditions that programs can handle (like IOException, FileNotFoundException). Errors (like OutOfMemoryError, StackOverflowError) represent serious problems that programs typically cannot recover from.

Java only requires catching checked exceptions. Runtime exceptions (RuntimeException and its subclasses) can be caught or ignored. A program can selectively catch only the exceptions it wants to handle.

In Java, Throwable is the ultimate superclass of all errors and exceptions. While Exception is the superclass of all checked and unchecked exceptions, it inherits from Throwable. Therefore, saying Exception is the absolute superclass of all exceptional events is technically false because Throwable sits at the top of the hierarchy.

Java throws an ArithmeticException when an exceptional arithmetic condition has occurred, such as integer division by zero. Other options like IntegerArithmeticException and DivideByZeroException do not exist in the standard Java library, while NumberFormatException is thrown when attempting to convert an invalid string to a numeric type.

A try block must be followed by either catch blocks, a finally block, or both. It's valid to have try-finally without any catch blocks. The finally block provides optional cleanup.

Exception handling in Java follows polymorphism. A catch block designed to handle a superclass exception type will also successfully catch any exception object that inherits from that superclass.

To solve the question, the user needs to know what parseInt() method does. The parseInt() method is used to convert a string to an integer. If the string argument cannot be parsed as an integer, parseInt() throws a NumberFormatException.

Now, let's go through each option and explain why it is right or wrong:

A. NumberError: There is no exception called NumberError in Java. This option is incorrect.

B. ArithmeticException: The ArithmeticException is thrown when an exceptional arithmetic condition has occurred. Since parseInt() throws a NumberFormatException, this option is incorrect.

C. RunTimeException: RuntimeException is a superclass of all classes that represent exceptional conditions that occur during the execution of Java code. Since NumberFormatException is a subclass of RuntimeException, this option is partially correct. However, the specific exception thrown by parseInt() is NumberFormatException.

D. NumberFormatException: This is the correct answer. When parseInt() gets illegal data, it throws a NumberFormatException. This exception is thrown to indicate that the application has attempted to convert a string to one of the numeric types, but that the string does not have the appropriate format.

Therefore, the answer is: D. NumberFormatException.

The code is illegal because ExceptionA is a checked exception thrown by thrower(). The try block only catches ExceptionB, which is a subclass of ExceptionA. Since the superclass exception ExceptionA is neither caught nor declared in the main method's signature, the code fails to compile.

To answer this question, the user needs to know about the try-catch-finally block in exception handling.

Option A is true because not all statements in a try{} block will throw an exception, some statements may never throw an exception.

Option B is true because the statements in a try{} block may throw several types of exception.

Option C is false because the try{} block can contain loops and branches.

Option D is false because the try{} block can appear anywhere in the try-catch-finally block, as long as it appears before the catch{} and finally{} blocks.

Therefore, the answer is:

The Answer is: C. The try{} block can not contain loops or branches.

In exception handling, catch blocks must be ordered from most specific to most general. A child exception class (more specific) must have its catch block BEFORE a parent exception class (more general). If a parent catch block comes first, it would catch all exceptions including child types, making child catch blocks unreachable. Therefore, the statement that child catch blocks must FOLLOW parent catch blocks is FALSE.

When an exception is thrown in a try block and no matching catch block exists, the exception propagates up the call stack. The method throws the exception to its caller, following Java's exception propagation mechanism. This allows higher-level methods to handle the exception or continue propagating it. The program does not halt immediately, ignore the exception, or fail to compile - this is legal Java code.

A try/catch structure can have either zero or one finally block, and if present, it must be placed after the last catch block. The finally block is optional but when used, there can only be one per try/catch structure. It cannot appear after each catch block individually, nor can there be multiple finally blocks. This ensures clean, predictable structure for cleanup code.

A finally block is ALWAYS executed after execution leaves the try block, regardless of how it exits - whether via normal completion, a caught or uncaught exception, return, break, or continue statements. This guarantee makes finally blocks ideal for cleanup code that must run under all circumstances. The finally block executes even when no exception occurs or when the exception is caught.

Java is a high-level, class-based, object-oriented programming language designed to have as few implementation dependencies as possible. It was developed by Sun Microsystems (now Oracle) and is widely used for enterprise applications, Android development, and web backends. Coffee was the original inspiration for the name, but Java itself is code.

An applet is a small Java program designed to run within a web browser as part of an HTML page. Applets were a key feature of Java in the late 1990s for bringing dynamic content to the web before modern JavaScript frameworks. They execute in a sandboxed JVM on the client side.

Java's 'write once, run anywhere' philosophy means compiled Java bytecode runs on any platform with a Java Virtual Machine (JVM). This includes Windows, Unix/Linux, macOS, and many others. The JVM abstracts platform differences, making Java highly portable across operating systems.

In Java applets, painting requires a proper class structure extending Applet or JApplet to provide the drawing surface. Import statements are needed for graphics classes like Graphics. The drawString method must be called within a method like paint() that belongs to a properly defined applet class. All three reasons explain why a single painting line is insufficient.